DEV Community: Javonet

Make ASCII Art Anywhere_ Use Python’s `pyfiglet` in Ruby, .NET Core, and Node.js with Javonet

Javonet — Thu, 21 Aug 2025 13:48:29 +0000

Have you ever wanted to spice up your terminal app with something fun? Something expressive? Something old school but timeless?

Let’s talk about ASCII art—yes, the stuff you saw in the early days of the internet that made you smile. With Python’s pyfiglet library, generating beautiful ASCII banners is a breeze. But here s the twist: you don’t need to write your application in Python to use it.

With Javonet, you can embed Python code directly into Ruby, .NET Core, or Node.js projects and call libraries like pyfiglet as if they were native. Of course, there are many implementations of FIGlet across various technologies—but the goal of this article is to show you just how effortlessly you can use Javonet, and hopefully leave you wondering: “What else could I integrate this easily?”

Let’s explore how to unleash this ASCII magic in any language you like.

What Is `pyfiglet`?

pyfiglet is a full Python port of the original FIGlet tool. It turns simple text into stylish ASCII banners using various fonts. It's perfect for:

CLI tool branding
Fun debugging messages
Welcome screens
Easter eggs in your code

Here’s what it does in Python:

# Just for reference
from pyfiglet import Figlet

f = Figlet(font="slant")
ascii_art = f.renderText("Hello from Python!")
print(ascii_art)

Output:

$ python figlet.py                                           
    __  __     ____         ____                   
   / / / /__  / / /___     / __/________  ____ ___ 
  / /_/ / _ \/ / / __ \   / /_/ ___/ __ \/ __ `__ \
 / __  /  __/ / / /_/ /  / __/ /  / /_/ / / / / / /
/_/ /_/\___/_/_/\____/  /_/ /_/   \____/_/ /_/ /_/ 

    ____        __  __                __
   / __ \__  __/ /_/ /_  ____  ____  / /
  / /_/ / / / / __/ __ \/ __ \/ __ \/ / 
 / ____/ /_/ / /_/ / / / /_/ / / / /_/  
/_/    \__, /\__/_/ /_/\____/_/ /_(_)   
      /____/

Looks awesome, right? But why should only Python developers get to use it?

With Javonet, you can bring pyfiglet (and any other Python library) to your non-Python project in just a few lines of code.

Cross-Language Code with Javonet

Javonet is a lightweight bridge that connects your main project’s language to another runtime—like Python. It works in-process, meaning no APIs, no socket servers, no awkward wrappers.

With Javonet, you can:

Load Python modules directly from .NET, Node.js, or Ruby
Access Python classes and functions
Pass and retrieve data across runtimes instantly

This means you can call Figlet renderTest from any language as if it were part of that language.

And best of all? It’s fast, secure, and cross-platform.

Setup Prerequisites

Before we start, you’ll need to:

✅ Install Python and pyfiglet via pip install pyfiglet
✅ Download the Javonet SDK and grab a free trial license
✅ Set up your project in your language of choice (Ruby, .NET Core, or Node.js)

Once that’s ready, you’re good to go!

Use `pyfiglet` in Ruby with Javonet

Ruby is clean, expressive, and joyful—but calling Python? That’s historically been tricky. Not anymore.

With Javonet, the integration is seamless.

🔧 Ruby Example

# figlet.rb
require 'javonet-ruby-sdk'
Javonet.activate("<your-javonet-key>")

called_runtime = Javonet.in_memory.python

figlet = called_runtime.get_type('pyfiglet.Figlet').create_instance("slant").execute
result = figlet.invoke_instance_method("renderText", "Python Figlet from Ruby!").execute

puts result.get_value

This script:

Initializes the Python runtime
Loads the pyfiglet module
Calls renderText("Python Figlet from Ruby!")
Prints the ASCII result directly to the Ruby console

And yes—it looks exactly as cool as it sounds.

ruby figlet.rb
    ____        __  __                   _______       __     __ 
   / __ \__  __/ /_/ /_  ____  ____     / ____(_)___ _/ /__  / /_
  / /_/ / / / / __/ __ \/ __ \/ __ \   / /_  / / __ `/ / _ \/ __/
 / ____/ /_/ / /_/ / / / /_/ / / / /  / __/ / / /_/ / /  __/ /_  
/_/    \__, /\__/_/ /_/\____/_/ /_/  /_/   /_/\__, /_/\___/\__/  
      /____/                                 /____/              
    ____                        ____        __          __
   / __/________  ____ ___     / __ \__  __/ /_  __  __/ /
  / /_/ ___/ __ \/ __ `__ \   / /_/ / / / / __ \/ / / / / 
 / __/ /  / /_/ / / / / / /  / _, _/ /_/ / /_/ / /_/ /_/  
/_/ /_/   \____/_/ /_/ /_/  /_/ |_|\__,_/_.___/\__, (_)   
                                              /____/

Use `pyfiglet` in .NET Core (C#) with Javonet

Whether you're building internal dev tools or enterprise CLI utilities, .NET Core offers powerful tooling. But what if you want to jazz up your terminal output?

Calling pyfiglet from C# is not just possible—it’s a Javonet lifestyle.

🔧 .NET Core (C#) Example

// figlet.csproj
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Javonet.Netcore.Sdk" Version="2.5.20" />
  </ItemGroup>

</Project>

using Javonet.Netcore.Sdk;

class Program
{
    static void Main(string[] args)
    {
        Javonet.Netcore.Sdk.Javonet.Activate("<your-javonet-key>");
        var calledRuntime = Javonet.Netcore.Sdk.Javonet.InMemory().Python();
        var calledRuntimeType = calledRuntime.GetType("pyfiglet.Figlet").Execute();
        var response = calledRuntimeType.CreateInstance("slant").InvokeInstanceMethod("renderText", "Hello figlet from .NET!").Execute();
        Console.WriteLine(response.GetValue());
    }
}

dotnet run
    __  __     ____         _____       __     __     ____                   
   / / / /__  / / /___     / __(_)___ _/ /__  / /_   / __/________  ____ ___ 
  / /_/ / _ \/ / / __ \   / /_/ / __ `/ / _ \/ __/  / /_/ ___/ __ \/ __ `__ \
 / __  /  __/ / / /_/ /  / __/ / /_/ / /  __/ /_   / __/ /  / /_/ / / / / / /
/_/ /_/\___/_/_/\____/  /_/ /_/\__, /_/\___/\__/  /_/ /_/   \____/_/ /_/ /_/ 
                              /____/                                         
      _   ________________
     / | / / ____/_  __/ /
    /  |/ / __/   / / / / 
 _ / /|  / /___  / / /_/  
(_)_/ |_/_____/ /_/ (_)

Now your .NET Core app can welcome users with ASCII banners or display warning messages in bold, retro flair.

Want to support multiple banner styles? pyfiglet has dozens of fonts ready to go.

Use `pyfiglet` in Node.js with Javonet

Node.js is ideal for scripting, tooling, bots, and developer utilities. And pyfiglet is the perfect way to add visual flair.

With Javonet, calling Python code from Node.js is no different than requiring a regular module.

🔧 Node.js Example

//figlet.js
const { Javonet } = require('javonet-nodejs-sdk');

Javonet.activate("<your-javonet-key>");

let calledRuntime = Javonet.inMemory().python();
calledRuntime.loadLibrary('.');

let calledRuntimeType = calledRuntime.getType("pyfiglet.Figlet").createInstance("slant").execute();

let response = calledRuntimeType.invokeInstanceMethod("renderText", "Hello from nodejs!").execute();

let result = response.getValue();
console.log(result);

    __  __     ____         ____
   / / / /__  / / /___     / __/________  ____ ___
  / /_/ / _ \/ / / __ \   / /_/ ___/ __ \/ __ `__ \
 / __  /  __/ / / /_/ /  / __/ /  / /_/ / / / / / /
/_/ /_/\___/_/_/\____/  /_/ /_/   \____/_/ /_/ /_/

                    __       _      __
   ____  ____  ____/ /__    (_)____/ /
  / __ \/ __ \/ __  / _ \  / / ___/ /
 / / / / /_/ / /_/ /  __/ / (__  )_/
/_/ /_/\____/\__,_/\___/_/ /____(_)
                      /___/

You’ll be surprised how much personality a little ASCII can add to your Node.js tool.

Want to go further? Dynamically change the banner based on user input or environment.

Going Beyond Hello World

Sure, renderText("Hello") is fun. But pyfiglet offers so much more. With Javonet, you can:

🖋 Change fonts:

pyfiglet.renderText("Hello figlet from .NET!", font="cola")

vscode ➜ /workspaces/art/FigletApp $ dotnet run
    __  __     ____         _____       __     __     ____                   
   / / / /__  / / /___     / __(_)___ _/ /__  / /_   / __/________  ____ ___ 
  / /_/ / _ \/ / / __ \   / /_/ / __ `/ / _ \/ __/  / /_/ ___/ __ \/ __ `__ \
 / __  /  __/ / / /_/ /  / __/ / /_/ / /  __/ /_   / __/ /  / /_/ / / / / / /
/_/ /_/\___/_/_/\____/  /_/ /_/\__, /_/\___/\__/  /_/ /_/   \____/_/ /_/ /_/ 
                              /____/                                         
      _   ________________
     / | / / ____/_  __/ /
    /  |/ / __/   / / / / 
 _ / /|  / /___  / / /_/  
(_)_/ |_/_____/ /_/ (_)   


vscode ➜ /workspaces/art/FigletApp $ dotnet run

     `;   .'           .;    .;            .-.            .;           .   
    _ `; ; (          .;'   .;'           ; -'.-.        .;'       ...;... 
   (  ;' ;  ) .-.    .;    .;  .-.      -;--  `-',:.,'  .;  .-.     .'     
    `.;__;.'.;.-'   ::    ::  ;   ;'    .    ;' :   ;  :: .;.-'   .;       
 .  .:'  `:. `:::'_;;_.-_;;_.-`;;'   `.'  _.;:._.`-:'_;;_.-`:::'.;         
(_.'       `:                                  -._:'                       
      .-.                             .-.              .-.-.;;;;;;'.;. 
     ; -'                               ;  :   .;;;.`-' (_)  .;   ;;;' 
   -;--.;.::..-.  . ,';.,';.          .;:  :  ;;  (_)        :   .;'   
   .   .;   ;   ;';;  ;;  ;;  .-.    .;' \ :  .;;; .-.     .:'  .-.    
`.'  .;'    `;;' ';  ;;  ';   `-'.:'.;    \: ;;  .;  ;   .-:._  `-'    
                _;        `-'   (__.'      `.`;.___.'   (_/  `-

🖍 Combine with ANSI color libraries in your host language
🧪 Wrap ASCII banners around exception messages
🎁 Auto-generate headers for your CLI tools

Since pyfiglet supports over 100 different fonts, you’ll never run out of ways to surprise your users.

Why It Matters

You might wonder: why bother? Why not just rewrite pyfiglet in Ruby, C#, or JavaScript?

Because:

✅ The Python ecosystem is rich and battle-tested
✅ Reusing libraries reduces time, bugs, and effort
✅ You can innovate faster when you're not reinventing the wheel

With Javonet, you’re not locked into one language anymore. You can cherry-pick the best tools from any ecosystem and bring them into your own.

Final Thoughts

ASCII banners may seem playful—but they’re just the beginning.

This example with pyfiglet shows how easy and powerful it is to call Python code from Ruby, .NET Core, or Node.js using Javonet. Whether it’s machine learning, data visualization, or text formatting, Javonet makes cross-language integration a breeze.

So next time you want to add character (literally) to your app…

💡 Just renderText() it—no matter the language.

Want to try it yourself?
➡ Get started with Javonet here
➡ Explore pyfiglet on GitHub

Stay creative, stay cross-language—and make ASCII art great again! 🎨

Wrap Once, Run Everywhere_ Integrating Python with .NET, Java, and Node.js using Javonet

Javonet — Thu, 31 Jul 2025 13:40:13 +0000

Introduction

In today’s diverse software landscape, integrating code across different technologies has become not just useful, but often essential. Imagine writing your core business logic once in Python and then instantly making it available to a .NET, Java, or Node.js application — without rewriting or rearchitecting your solution. With Javonet, this vision becomes a reality.

Javonet allows you to create native wrappers around your Python code, providing a natural, idiomatic interface for foreign technologies. This approach brings the best of both worlds: you maintain the simplicity and productivity of Python while exposing your functionality seamlessly to external platforms. No complex API layers, no messy middleware — just clean, native interoperability.

In this article, we'll build a simple Python module and demonstrate how elegantly it can be wrapped for use in .NET, Java, and Node.js applications. Whether you’re modernizing an existing system, creating cross-platform libraries, or simply looking to maximize code reuse, Javonet offers a powerful and developer-friendly solution.

Let’s dive in and see how easy it can be to bridge the gap between languages — the elegant way!null## Sample Python code

Let’s start by creating a simple Python class that we will later wrap and expose to other platforms. Our class, MyClass, contains two basic methods: one returns a greeting message, and the other performs a simple addition.

Here is the Python code:

class MyClass:
    __type__ = "MyClass"

    def hello_world(self) -> str:
        return "Hello, World from Python Class!!"

    def add(self, a: int, b: int) -> int:
        return a + b

The hello_world method simply returns a friendly greeting.
The add method takes two integers and returns their sum.

Notice the __type__ attribute defined at the top of the class. This attribute can be used to explicitly set the class type name when working with Javonet, making it easier to reference this class from external platforms like .NET, Java, or Node.js.

Now that we have our Python logic ready, let’s see how we can elegantly wrap and access it from different technologies using Javonet.

Wrapping the Python Class for .NET

To expose our Python class MyClass to a .NET application using Javonet, we will create a native .NET wrapper that feels completely natural for C# developers.
Our wrapper will consist of three elements:

An interface to define the contract.
A class implementation that internally delegates calls to the Python object.
A Program.cs file to demonstrate how to use the wrapper.

Let's break it down step-by-step:

Install nuget package

First, you need to install nuget package for your .NET application:

dotnet add package Javonet.Netcore.Sdk -s https://api.nuget.org/v3/index.json

If you want to use .NET Framework:

dotnet add package Javonet.Clr.Sdk -s https://api.nuget.org/v3/index.json

You also need to change class path in your code from: Javonet.Netcore.Sdk to Javonet.Clr.Sdk.

Create the Interface

First, define a simple interface that mirrors the methods of the Python class:

namespace Sample.Core
{
    public interface IWrapper
    {
        string HelloWorld();

        int Add(int a, int b);
    }
}

Implement the Wrapper Class

Now, create a class that implements the interface. This class will use Javonet to invoke the Python methods under the hood.
Let's create a class with a simple constructor. We need to create a new runtime context for Python by:

Javonet.Netcore.Sdk.Javonet.InMemory().Python();

and load the path to our Python files:

runtimeContext.LoadLibrary("your-python-files-path");

Then we can create an invocation context for our Python class:

_invocationContext = runtimeContext.GetType("MyClass.MyClass").Execute();

This will be the constructor for the Wrapper class:

namespace Sample.Core
{
    public class Wrapper : IWrapper
    {
        Javonet.Netcore.Sdk.InvocationContext _invocationContext;

        public Wrapper()
        {
            var runtimeContext = Javonet.Netcore.Sdk.Javonet.InMemory().Python();

            runtimeContext.LoadLibrary("your-python-files-path");

            _invocationContext = runtimeContext.GetType("MyClass.MyClass").Execute();
        }
    }
}

Now we can add the implementation for each method. In the final step, this class should look like the example below:

namespace Sample.Core
{
    public class Wrapper : IWrapper
    {
        Javonet.Netcore.Sdk.InvocationContext _invocationContext;

        public Wrapper()
        {
            var runtimeContext = Javonet.Netcore.Sdk.Javonet.InMemory().Python();

            runtimeContext.LoadLibrary("your-python-files-path");

            _invocationContext = runtimeContext.GetType("MyClass.MyClass").Execute();
        }

        public string HelloWorld()
        {
            var helloWorld = _invocationContext
                .InvokeInstanceMethod("hello_world", _invocationContext).Execute();
            return (string)helloWorld.GetValue();
        }

        public int Add(int a, int b)
        {
            var addResult = _invocationContext
                .InvokeInstanceMethod("add", _invocationContext, a, b).Execute();
            return (int)addResult.GetValue();
        }
    }
}

Build the Program Entry Point

The final step is to add a Program.cs class that will allow us to run and test our code. Within this class, we also need to handle the activation of Javonet:

Javonet.Netcore.Sdk.Javonet.Activate("your-license-key");

Of course, when implementing such a solution in a real project, you should initialize Javonet in a location that best suits the architecture and lifecycle of your application (for example, during application startup or within a dedicated initialization module).

For now, the complete Program.cs class should look like the example below:

using Sample.Core;

Console.WriteLine("Hello, World from .NET code!");

Javonet.Netcore.Sdk.Javonet.Activate("your-license-key");

var wrapper = new Wrapper();

Console.WriteLine(wrapper.HelloWorld());
Console.WriteLine($"Adding result from Python code: {wrapper.Add(5, 9)}");

Wrapping the Python Class for Java

To expose our Python class MyClass to a Java application using Javonet, we will follow a very similar structure to the .NET approach.
Our Java wrapper will consist of three elements:

An interface defining the contract.
A class implementation that internally delegates calls to the Python object.
A Program class to demonstrate how to run and test the solution.

Let's go through each part step-by-step:

Edit pom.xml file

You need to add Javonet to your pom.xml file:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.chatbot</groupId>
  <artifactId>chatbot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>chatbot.client</name>
  <description>test</description>

  <dependencies>
    <dependency>
      <groupId>com.javonet</groupId>
      <artifactId>javonet-java-sdk</artifactId>
      <version>2.5.16</version>
    </dependency>
  </dependencies>

</project>

Create the Interface

First, define a Java interface that mirrors the methods of the Python class:

public interface IWrapper {
    String helloWorld();

    int add(int a, int b);
}

Implement the Wrapper Class

Now, create a class that implements the interface. This class will use Javonet to invoke the Python methods behind the scenes:

import com.javonet.sdk.InvocationContext;
import com.javonet.sdk.Javonet;
import com.javonet.sdk.RuntimeContext;

public class Wrapper implements IWrapper {
    private InvocationContext invocationContext;

    public Wrapper() {
        RuntimeContext runtimeContext = Javonet.inMemory().python();

        runtimeContext.loadLibrary("your-python-files-path");

        invocationContext = runtimeContext.getType("MyClass.MyClass").execute();
    }

    @Override
    public String helloWorld() {
        InvocationContext helloWorld = invocationContext
                .invokeInstanceMethod("hello_world", invocationContext)
                .execute();
        return (String) helloWorld.getValue();
    }

    @Override
    public int add(int a, int b) {
        InvocationContext addResult = invocationContext
                .invokeInstanceMethod("add", invocationContext, a, b)
                .execute();
        return (Integer) addResult.getValue();
    }

}

Build the Program Entry Point

Finally, create a Program class that will initialize Javonet, create an instance of your wrapper, and invoke its methods to demonstrate everything works:

import com.javonet.sdk.Javonet;

public class Program {
  public static void main(String[] args) {
    Javonet.activate("your-license-key");

    System.out.println("Hello, World from JAVA code!!");

    Wrapper wrapper = new Wrapper();

    System.out.println(wrapper.helloWorld());
    System.out.println("Adding result from Python code: " + wrapper.add(5, 9));
    }
}

As with any real-world project, you might want to place the Javonet activation and runtime initialization in a more centralized location depending on your application's architecture.

Wrapping the Python Class for Node.js

For Node.js, the structure is slightly simpler compared to .NET and Java.
We will organize our solution into two files:

A wrapper.js file containing the wrapper class and all necessary logic.
A client.js file serving as the entry point to run and test the solution.

Let's walk through the structure:

Install packages

The first step is to add Javonet to your project by installing the required npm packages.
Simply run the following command to include Javonet in your project dependencies:

npm install javonet-nodejs-sdk

and:

npm install javonet-binaries

Create the Wrapper File

First, create a wrapper.js file that defines a class wrapping the Python functionality.
This class will:

Initialize the Javonet runtime.
Load the Python library.
Create an instance of the Python class.
Implement methods that internally delegate calls to the Python object.

const { Javonet } = require('javonet-nodejs-sdk');

class Wrapper {
  constructor() {
    const runtimeContext = Javonet.inMemory().python();

    runtimeContext.loadLibrary("your-python-files-path");

    this.invocationContext = runtimeContext
      .getType("MyClass.MyClass")
      .execute();
  }

  helloWorld() {
    const result = this.invocationContext
      .invokeInstanceMethod("hello_world", this.invocationContext)
      .execute();

    return result.getValue();
  }

  add(a, b) {
    const result = this.invocationContext
      .invokeInstanceMethod("add", this.invocationContext, a, b)
      .execute();

    return result.getValue();
  }
}

module.exports = Wrapper;

Create the Client File

Next, create a client.js file that will serve as the main entry point for your application.
This file will:

Require the wrapper.js module.
Activate Javonet
Instantiate the wrapper class.
Call its methods and display the results.

const {Javonet} = require('javonet-nodejs-sdk')
const Wrapper = require('./wrapper');

Javonet.activate("your-license-key");

console.log("Hello, World from NODEJS!!");

const wrapper = new Wrapper();

console.log(wrapper.helloWorld());
console.log("add(5, 7): ", wrapper.add(5, 7));

In a production-ready application, you might want to structure the initialization and runtime activation more cleanly, possibly separating configuration and runtime setup into a dedicated module.

Conclusion

As you can see, Javonet makes it incredibly easy to bridge your code with other technology stacks. By creating simple, native wrappers, you can seamlessly integrate your logic into external applications, without rewriting or reimplementing your core business functionality.

This approach not only boosts code reuse and consistency across platforms, but also allows teams to innovate faster by combining the strengths of different technologies in a clean, maintainable way.

Whether you are modernizing legacy systems, developing cross-platform libraries, or building scalable multi-language applications, Javonet offers a powerful and elegant solution to make interoperability effortless.
Now it’s your turn — take your code and connect it to the world!🚀

Write Once, Run Everywhere – Integrating JavaScript with Python, Java and .NET

Javonet — Wed, 16 Jul 2025 09:10:38 +0000

Introduction

In the ever-expanding ecosystem of modern software development, the need to reuse logic across platforms has evolved from a convenience to a strategic advantage. Imagine writing your business logic once in JavaScript — the language of the web — and immediately reusing it inside desktop, backend, or mobile applications built with Python, Java, or .NET. No translation layers, no rewrites — just direct, efficient reuse.

This is precisely the power Javonet brings to the table. By enabling native interoperability between JavaScript and other major platforms, Javonet allows you to wrap your existing Node.js modules and expose them as if they were native libraries in any target environment. You retain the speed and agility of JavaScript while delivering robust integrations across the stack.

In this article, we’ll take a simple JavaScript module and show how it can be embedded directly into applications written in Python, Java, and .NET. Whether you’re a frontend developer expanding into backend systems, a team leader maintaining multi-language projects, or an architect looking to maximize code reuse, Javonet offers a clean and seamless path toward true cross-platform integration.

Let’s explore how easy and elegant it can be to connect your JavaScript logic to the rest of your tech stack — without compromise.

[toc]

Code samples

Sample Python code

Here is the Python code:

class MyClass:
    __type__ = "MyClass"

    def hello_world(self) -> str:
        return "Hello, World from Python Class!!"

    def add(self, a: int, b: int) -> int:
        return a + b

The hello_world method simply returns a friendly greeting.
The add method takes two integers and returns their sum.

Now that we have our Python logic ready, let’s see how we can elegantly wrap and access it from different technologies using Javonet.

Sample Java code

We can now create an equivalent class in Java, preserving the same logic and structure to ensure seamless integration from other platforms.

Here is the Java code:

package com.mydomain.myjavaproject;

public class MyClass {
    public String helloWorld() {
        return "Hello, World from Java Class!!";
    }

    public int add(int a, int b) {
        return a + b;
    }
}

Sample .NET code

We can now create an equivalent class in .NET, following the same logic and naming conventions used in the Python and Java versions.

Here is the C# code:

namespace MyLibrary
{
    public class MyClass
    {
        public string HelloWorld()
        {
            return "Hello, World from C# Class!!";
        }

        public int Add(int a, int b)
        {
            return a + b;
        }
    }
}

Wrapping the code for Node.js

For Node.js, the structure is slightly simpler compared to .NET and Java.
We will organize our solution into two files:

A wrapper.js file containing the wrapper class and all necessary logic.
A client.js file serving as the entry point to run and test the solution.

Let's walk through the structure:

Install packages

The first step is to add Javonet to your project by installing the required npm packages.
Simply run the following command to include Javonet in your project dependencies:

npm install javonet-nodejs-sdk

and:

npm install javonet-binaries

Create the Wrapper File

First, create a wrapper.js file that defines a class wrapping the Python functionality.
This class will:

Initialize the Javonet runtime.
Load the Python library.
Create an instance of the Python class.
Implement methods that internally delegate calls to the Python object.

Python:

const { Javonet } = require('javonet-nodejs-sdk');

class PythonWrapper {
  constructor() {
    Javonet.activate("your-API-key");
    const runtimeContext = Javonet.inMemory().python();

    runtimeContext.loadLibrary("your-python-py-file");

    this.invocationContext = runtimeContext
      .getType("MyClass.MyClass")
      .execute();
  }

  helloWorld() {
    const result = this.invocationContext
      .invokeInstanceMethod("hello_world", this.invocationContext)
      .execute();

    return result.getValue();
  }

  add(a, b) {
    const result = this.invocationContext
      .invokeInstanceMethod("add", this.invocationContext, a, b)
      .execute();

    return result.getValue();
  }
}

module.exports = PythonWrapper;

Java:

const { Javonet } = require('javonet-nodejs-sdk');

class JavaWrapper {
  constructor() {
    Javonet.activate("your-API-key");
    const runtimeContext = Javonet.inMemory().jvm();

    runtimeContext.loadLibrary("your-jar-path");

    this.invocationContext = runtimeContext
      .getType("MyClass.MyClass")
      .execute();
  }

  helloWorld() {
    const result = this.invocationContext
      .invokeInstanceMethod("helloWorld", this.invocationContext)
      .execute();

    return result.getValue();
  }

  add(a, b) {
    const result = this.invocationContext
      .invokeInstanceMethod("add", this.invocationContext, a, b)
      .execute();

    return result.getValue();
  }
}

module.exports = JavaWrapper;

C#:

const { Javonet } = require('javonet-nodejs-sdk');

class CsharpWrapper {
  constructor() {
    Javonet.activate("your-API-key");

    // 'netcore' for .NET Core, 'clr' for .NET Framework
    const runtimeContext = Javonet.inMemory().netcore();

    runtimeContext.loadLibrary("your-DLL-path");

    this.invocationContext = runtimeContext
      .getType("MyClass.MyClass")
      .execute();
  }

  helloWorld() {
    const result = this.invocationContext
      .invokeInstanceMethod("HelloWorld", this.invocationContext)
      .execute();

    return result.getValue();
  }

  add(a, b) {
    const result = this.invocationContext
      .invokeInstanceMethod("Add", this.invocationContext, a, b)
      .execute();

    return result.getValue();
  }
}

module.exports = CsharpWrapper;

Create the Client File

Next, create a client.js file that will serve as the main entry point for your application.
This file will:

Require the wrapper.js module.
Activate Javonet
Instantiate the wrapper class.
Call its methods and display the results.

const PythonWrapper = require('./pythonWrapper');
const JavaWrapper = require('./javaWrapper');
const CsharpWrapper = require('./csharpWrapper')

console.log("Hello, World from NODEJS!!");

const pythonWrapper = new PythonWrapper();

console.log(pythonWrapper.helloWorld());
console.log("add(5, 7):", pythonWrapper.add(5, 7));

const javaWrapper = new JavaWrapper();

console.log(javaWrapper.helloWorld());
console.log("add(6, 4):", javaWrapper.add(6, 4));

const csharpWrapper = new CsharpWrapper();

console.log(csharpWrapper.helloWorld());
console.log("add(2, 1):", csharpWrapper.add(2, 1));

[!NOTE]
In a production-ready application, you might want to structure the initialization and runtime activation more cleanly, possibly separating configuration and runtime setup into a dedicated module.

Conclusion

As you've seen, Javonet empowers you to break the boundaries between platforms by making your JavaScript code instantly accessible to Python, Java, and .NET applications. With just a lightweight wrapper, you can expose your logic natively — without duplicating effort, introducing fragile glue code, or compromising maintainability.

This seamless integration not only accelerates development and ensures consistency, but also unlocks the full potential of a polyglot architecture — where each team can work in their preferred language, while sharing a common codebase underneath.

Whether you're migrating functionality from the frontend to backend, building SDKs for multiple platforms, or simply aiming to get more value out of your JavaScript modules, Javonet offers a clean, efficient, and developer-friendly path forward.

Now it’s your move — write once in JavaScript, and let it run everywhere! 🚀

How to combine WinForms UI and Python charting in minutes using Javonet.html

Javonet — Thu, 26 Jun 2025 11:36:52 +0000

Introduction

Creating modern desktop applications often involves choosing between languages and ecosystems: C# for fast GUI development with WinForms, or Python for its rich ecosystem of data processing and visualization libraries. But what if you could combine the strengths of both—without rewriting code or setting up complex interop layers?

In this article, we’ll show you how to build a .NET WinForms application that leverages Python logic to generate dynamic SVG charts. Using Javonet, a cross-language integration bridge, you can seamlessly call Python code from your C# application with zero hassle. The result is a clean and maintainable hybrid architecture where C# handles the interface, and Python does the heavy lifting for data visualization.

Let’s walk through a practical example: a chart editor in WinForms that takes X and Y values from the user and visualizes them using Python’s svgwrite library. You’ll see how easy it is to pass data between the two worlds—and how little boilerplate is needed.

Prerequisites

Before you get started, make sure you have the following tools and packages installed:

.NET (C#/WinForms) side

Visual Studio 2019+ (or any IDE with .NET WinForms support)
A .NET Framework or .NET Core WinForms project
The following NuGet packages added to your project:

Install-Package SkiaSharp
Install-Package SkiaSharp.Views.WindowsForms
Install-Package Svg.Skia
Install-Package Javonet.Netcore.Sdk #or Javonet.Clr.Sdk for .NET Framework

Python side

Python 3.8 or later
Install the svgwrite package:

pip install svgwrite

Creating the Python `Charts` Class

We’ll now create the core component on the Python side: a class called Charts that generates an SVG line chart using the svgwrite library.

This class will expose a method named generate_line_chart_svg(...) which accepts a title, a list of X and Y values, and returns a raw SVG string ready to be rendered inside a WinForms PictureBox.

charts.py

import tempfile
import svgwrite

class Charts:
    __type__ = "Charts"  # Optional identifier (useful for Javonet interop)

    def generate_line_chart_svg(self, title, x_vals, y_vals, width=800, height=600):
        # Create an SVG drawing canvas with a fixed width and height
        dwg = svgwrite.Drawing(size=(width, height))

        # Set margins around the chart area to leave space for axes and labels
        margin = 50
        plot_width = width - 2 * margin
        plot_height = height - 2 * margin

        # Draw Y axis (left vertical line)
        dwg.add(dwg.line(
            start=(margin, margin),
            end=(margin, height - margin),
            stroke='black'
        ))

        # Draw X axis (bottom horizontal line)
        dwg.add(dwg.line(
            start=(margin, height - margin),
            end=(width - margin, height - margin),
            stroke='black'
        ))

        # Calculate data ranges
        max_x = max(x_vals)
        min_x = min(x_vals)
        max_y = max(y_vals)
        min_y = min(y_vals)

        # Avoid division by zero by defaulting to 1 if min == max
        scale_x = plot_width / (max_x - min_x if max_x != min_x else 1)
        scale_y = plot_height / (max_y - min_y if max_y != min_y else 1)

        # Function to map data points (x, y) to pixel coordinates in the SVG canvas
        def transform(x, y):
            tx = margin + (x - min_x) * scale_x
            ty = height - margin - (y - min_y) * scale_y  # invert Y-axis for correct chart direction
            return (tx, ty)

        # Apply transformation to all data points
        points = [transform(x, y) for x, y in zip(x_vals, y_vals)]

        # Draw the polyline connecting all points
        dwg.add(dwg.polyline(
            points=points,
            fill='none',
            stroke='black',
            stroke_width=2
        ))

        # Draw a red dot at each point for better visibility
        for point in points:
            dwg.add(dwg.circle(center=point, r=3, fill='red'))

        # Add the chart title centered at the top of the canvas
        dwg.add(dwg.text(
            title,
            insert=(width / 2, margin / 2),
            text_anchor="middle",
            font_size=20
        ))

        # Return the full SVG content as a string
        return dwg.tostring()

Before wiring this up to your C# application, you can easily test the chart generator on its own. The following helper function allows you to render the SVG in a temporary HTML file and open it in your default browser.

def preview_svg_in_browser(svg_content):
    # Save the SVG content to a temporary HTML file
    with tempfile.NamedTemporaryFile(delete=False, suffix=".html", mode="w", encoding="utf-8") as f:
        html = f"""<!DOCTYPE html>
        <html>
            <head><meta charset="utf-8"><title>SVG Preview</title></head>
            <body>
                {svg_content}
            </body>
        </html>"""
        f.write(html)
        file_path = f.name

    # Open the file in the default system browser
    webbrowser.open(f"file://{file_path}")

You can call this test locally using the standard Python __main__ entry point:

if __name__ == "__main__":
    charts = Charts()
    # Provide sample X and Y data
    svg = charts.generate_line_chart_svg("Demo Chart", [1, 2, 3, 4], [10, 5, 30, 15])
    # Open the generated chart in your browser
    preview_svg_in_browser(svg)

✅ What to Expect
Running the script will open your browser with a simple line chart. This ensures that your Python environment, the svgwrite package, and the SVG rendering logic all work before integrating with the .NET layer through Javonet.

Building the WinForms UI in C

On the .NET side, we’ll use WinForms to build a minimal user interface that lets the user input chart data (as comma-separated values) and displays the generated SVG chart.

Our UI is composed of two main components:

ChartInputPanel – A panel with input fields and a button to trigger chart generation.
ChartDisplayPanel – A picture box capable of rendering SVG content returned from Python.

ChartInputPanel.cs
This panel handles user input and parses it into numeric arrays.

public class ChartInputPanel : Panel
{
    private readonly TextBox inputX;
    private readonly TextBox inputY;
    private readonly Button generateButton;

    public event EventHandler<ChartInputEventArgs> GenerateChartClicked;

    public ChartInputPanel()
    {
        Padding = new Padding(10);

        // Create and add the "Generate Chart" button
        generateButton = new Button { Text = "Generate Chart", Dock = DockStyle.Top, Height = 40 };
        generateButton.Click += (s, e) => OnGenerateChartClicked();
        Controls.Add(generateButton);

        // Input field for Y-values
        Controls.Add(new Label { Text = "Values Y (e.g. 10,20,30)", Dock = DockStyle.Top });
        inputY = new TextBox { Dock = DockStyle.Top };
        Controls.Add(inputY);

        // Input field for X-values
        Controls.Add(new Label { Text = "Values X (e.g. 1,2,3)", Dock = DockStyle.Top });
        inputX = new TextBox { Dock = DockStyle.Top };
        Controls.Add(inputX);
    }

    // Handles the button click and raises an event with parsed input
    private void OnGenerateChartClicked()
    {
        try
        {
            // Split input values and convert to arrays of doubles
            string[] xStr = inputX.Text.Split(',');
            string[] yStr = inputY.Text.Split(',');

            double[] x = Array.ConvertAll(xStr, double.Parse);
            double[] y = Array.ConvertAll(yStr, double.Parse);

            // Fire the event to inform the main form that a chart should be generated
            GenerateChartClicked?.Invoke(this, new ChartInputEventArgs(x, y));
        }
        catch (Exception ex)
        {
            MessageBox.Show("Input data error: " + ex.Message);
        }
    }
}

ChartInputEventArgs.cs
This simple data container class is used to pass chart data (X and Y arrays) when the user clicks "Generate Chart".

public class ChartInputEventArgs : EventArgs
{
    public double[] XValues { get; }
    public double[] YValues { get; }

    public ChartInputEventArgs(double[] x, double[] y)
    {
        XValues = x;
        YValues = y;
    }
}

ChartDisplayPanel.cs
This component is a customized PictureBox that knows how to render an SVG image using Svg.Skia and SkiaSharp.

public class ChartDisplayPanel : PictureBox
{
    public ChartDisplayPanel()
    {
        this.SizeMode = PictureBoxSizeMode.Zoom;
        this.BorderStyle = BorderStyle.FixedSingle;
    }

    // Accepts an SVG string and renders it into a Bitmap
    public void DisplayImage(string svgContent)
    {
        Image = RenderSvgToBitmap(svgContent, Width, Height);
    }

    private Bitmap RenderSvgToBitmap(string svg, int width, int height)
    {
        using (var svgStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(svg)))
        {
            var skSvg = new SKSvg();
            skSvg.Load(svgStream);

            var bitmap = new SKBitmap(width, height);
            using (var canvas = new SKCanvas(bitmap))
            {
                canvas.Clear(SKColors.Transparent);

                var scale = Math.Min(
                    width / skSvg.Picture.CullRect.Width,
                    height / skSvg.Picture.CullRect.Height);

                canvas.Scale((float)scale);
                canvas.DrawPicture(skSvg.Picture);
            }

            return SkiaSharp.Views.Desktop.Extensions.ToBitmap(bitmap);
        }
    }
}

Calling Python from C# with Javonet

Designing the MainForm.cs

The MainForm class is the entry point of your WinForms application. It brings together the UI components and the logic required to communicate with Python through Javonet. Here's how it works step-by-step.

Layout and Components

The form is divided into two main sections:

Left Panel – Contains the ChartInputPanel with fields to enter X and Y values.
Main Area – A ChartDisplayPanel that renders the SVG chart based on the Python output.

These components are added using DockStyle so the layout is responsive and clean.

MainForm.cs – Constructor Overview

using JN = Javonet.Netcore.Sdk;

namespace Charts
{
    public partial class MainForm : Form
    {
        private readonly ChartInputPanel _inputPanel;
        private readonly ChartDisplayPanel _chartDisplay;
        private readonly JN.RuntimeContext _pythonRuntime;

        public MainForm()
        {
            Text = "Python Chart Generator via Javonet";
            Size = new Size(800, 600);

            _inputPanel = new ChartInputPanel { Dock = DockStyle.Left, Width = 250 };
            _chartDisplay = new ChartDisplayPanel { Dock = DockStyle.Fill };

            _inputPanel.GenerateChartClicked += OnGenerateChart;

            Controls.Add(_chartDisplay);
            Controls.Add(_inputPanel);

            [...]

            InitializeComponent();
        }

        private void OnGenerateChart(object sender, ChartInputEventArgs e)
        {
            [...]
        }
    }
}

Explanation:

Text and Size set the window title and dimensions.
_inputPanel is docked to the left, taking fixed width.
_chartDisplay fills the remaining space, scaling automatically.
The event GenerateChartClicked is subscribed to by OnGenerateChart, which will later call Python and render the result.
The [ ... ] placeholder will contain Javonet runtime initialization (we’ll fill it in the next section).

Completing the MainForm Constructor

Python Runtime Initialization
To finish the MainForm setup, we need to initialize the Javonet runtime for Python and load the Charts class from your Python script.

This initialization should happen directly inside the constructor, after adding UI controls but before the call to InitializeComponent() (or right after, depending on your layout preference).

Here’s what this final initialization block should do:

Activate the Javonet using your API key.
Initialize the Python runtime context.
Set the RuntimeClasspath to point to the folder where charts.py is located.
Load the Charts class from Python and create its instance.
Store that instance in a private field so it can be used later to generate charts.

This instance (chartsInstance) will then be used in the OnGenerateChart(...) method to call the generate_line_chart_svg(...) function and get the resulting SVG.

⚠️ Make sure the path to your charts.py is correct and Python is installed and accessible from the system PATH.

Our constructor should look like this:

public MainForm()
{
    Text = "Python Chart Generator via Javonet";
    Size = new Size(800, 600);

    _inputPanel = new ChartInputPanel { Dock = DockStyle.Left, Width = 250 };
    _chartDisplay = new ChartDisplayPanel { Dock = DockStyle.Fill };

    _inputPanel.GenerateChartClicked += OnGenerateChart;

    Controls.Add(_chartDisplay);
    Controls.Add(_inputPanel);

    JN.Javonet.Activate("your-API-key");
    _pythonRuntime = JN.Javonet.InMemory().Python();

    var path = @"your charts.py path";

    _pythonRuntime.LoadLibrary(path);

    InitializeComponent();
}

Implementing OnGenerateChart – Calling Python and Rendering the Chart
With the UI layout complete and the Python Charts class successfully loaded using Javonet, it’s time to implement the heart of the interaction: the OnGenerateChart method.

This method will be triggered whenever the user clicks the “Generate Chart” button. Here’s what it needs to accomplish:

Read the X and Y values from the event arguments (ChartInputEventArgs).
Call the Python method generate_line_chart_svg(...) using the Javonet instance of the Charts class.
Receive the SVG content as a string.
Render the SVG into a Bitmap using Svg.Skia and show it in the ChartDisplayPanel.

By the end of this step, you’ll have a fully working hybrid desktop application — a native .NET UI powered by Python logic behind the scenes.

Final implementation of the OnGenerateChart() method should look like this:

try
{
    if (e.XValues.Length != e.YValues.Length)
    {
        MessageBox.Show("X and Y must have the same number of elements.");
        return;
    }

    var instance = _pythonRuntime.GetType("charts.Charts").CreateInstance();

    var x = e.XValues;
    var y = e.YValues;

    var svg = instance.InvokeInstanceMethod("generate_line_chart_svg", "Demo Chart", x, y).Execute();
    var result = (string)svg.GetValue();

    _chartDisplay.DisplayImage(result);
}
catch (Exception ex)
{
    MessageBox.Show("Error: " + ex.Message);
}

Conclusion

By combining the strengths of .NET WinForms for user interfaces and Python for expressive data visualization, you unlock the best of both worlds. Thanks to Javonet, integrating Python logic into your C# application becomes a straightforward and elegant process—no external processes, no manual data serialization, and no glue code.

Whether you want to reuse existing Python models, call scientific libraries, or offload chart generation like in our example, Javonet makes cross-language integration effortless. In just a few lines of code, you can call Python methods, receive SVG strings, and render them natively inside your .NET application.

This approach not only saves time and effort but also encourages modular, maintainable, and multi-language development—ideal for teams that already rely on Python for logic or analytics.

Try it yourself and see how Javonet opens up a whole new layer of flexibility in desktop application development.

Wrap Once, Run Everywhere_ Integrating Python with .NET, Java, and Node.js using Javonet

Javonet — Thu, 26 Jun 2025 11:35:48 +0000

Wrap Once, Run Everywhere: Integrating Python with .NET, Java, and Node.js using Javonet

Introduction

Let’s dive in and see how easy it can be to bridge the gap between languages — the elegant way!

[toc]

Sample Python code

Here is the Python code:

class MyClass:
    __type__ = "MyClass"

    def hello_world(self) -> str:
        return "Hello, World from Python Class!!"

    def add(self, a: int, b: int) -> int:
        return a + b

The hello_world method simply returns a friendly greeting.
The add method takes two integers and returns their sum.

Now that we have our Python logic ready, let’s see how we can elegantly wrap and access it from different technologies using Javonet.

Wrapping the Python Class for .NET

An interface to define the contract.
A class implementation that internally delegates calls to the Python object.
A Program.cs file to demonstrate how to use the wrapper.

Let's break it down step-by-step:

Install nuget package

First, you need to install nuget package for your .NET application:

dotnet add package Javonet.Netcore.Sdk -s https://api.nuget.org/v3/index.json

If you want to use .NET Framework:

dotnet add package Javonet.Clr.Sdk -s https://api.nuget.org/v3/index.json

[!NOTE]
You also need to change class path in your code from: Javonet.Netcore.Sdk to Javonet.Clr.Sdk.

Create the Interface

First, define a simple interface that mirrors the methods of the Python class:

namespace Sample.Core
{
    public interface IWrapper
    {
        string HelloWorld();

        int Add(int a, int b);
    }
}

Implement the Wrapper Class

Javonet.Netcore.Sdk.Javonet.InMemory().Python();

and load the path to our Python files:

runtimeContext.LoadLibrary("your-python-files-path");

Then we can create an invocation context for our Python class:

_invocationContext = runtimeContext.GetType("MyClass.MyClass").Execute();

This will be the constructor for the Wrapper class:

namespace Sample.Core
{
    public class Wrapper : IWrapper
    {
        Javonet.Netcore.Sdk.InvocationContext _invocationContext;

        public Wrapper()
        {
            var runtimeContext = Javonet.Netcore.Sdk.Javonet.InMemory().Python();

            runtimeContext.LoadLibrary("your-python-files-path");

            _invocationContext = runtimeContext.GetType("MyClass.MyClass").Execute();
        }
    }
}

Now we can add the implementation for each method. In the final step, this class should look like the example below:

namespace Sample.Core
{
    public class Wrapper : IWrapper
    {
        Javonet.Netcore.Sdk.InvocationContext _invocationContext;

        public Wrapper()
        {
            var runtimeContext = Javonet.Netcore.Sdk.Javonet.InMemory().Python();

            runtimeContext.LoadLibrary("your-python-files-path");

            _invocationContext = runtimeContext.GetType("MyClass.MyClass").Execute();
        }

        public string HelloWorld()
        {
            var helloWorld = _invocationContext
                .InvokeInstanceMethod("hello_world", _invocationContext).Execute();
            return (string)helloWorld.GetValue();
        }

        public int Add(int a, int b)
        {
            var addResult = _invocationContext
                .InvokeInstanceMethod("add", _invocationContext, a, b).Execute();
            return (int)addResult.GetValue();
        }
    }
}

Build the Program Entry Point

The final step is to add a Program.cs class that will allow us to run and test our code. Within this class, we also need to handle the activation of Javonet:

Javonet.Netcore.Sdk.Javonet.Activate("your-license-key");

[!NOTE]
Of course, when implementing such a solution in a real project, you should initialize Javonet in a location that best suits the architecture and lifecycle of your application (for example, during application startup or within a dedicated initialization module).

For now, the complete Program.cs class should look like the example below:

using Sample.Core;

Console.WriteLine("Hello, World from .NET code!");

Javonet.Netcore.Sdk.Javonet.Activate("your-license-key");

var wrapper = new Wrapper();

Console.WriteLine(wrapper.HelloWorld());
Console.WriteLine($"Adding result from Python code: {wrapper.Add(5, 9)}");

Wrapping the Python Class for Java

To expose our Python class MyClass to a Java application using Javonet, we will follow a very similar structure to the .NET approach.
Our Java wrapper will consist of three elements:

An interface defining the contract.
A class implementation that internally delegates calls to the Python object.
A Program class to demonstrate how to run and test the solution.

Let's go through each part step-by-step:

Edit pom.xml file

You need to add Javonet to your pom.xml file:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.chatbot</groupId>
  <artifactId>chatbot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>chatbot.client</name>
  <description>test</description>

  <dependencies>
    <dependency>
      <groupId>com.javonet</groupId>
      <artifactId>javonet-java-sdk</artifactId>
      <version>2.5.16</version>
    </dependency>
  </dependencies>

</project>

Create the Interface

First, define a Java interface that mirrors the methods of the Python class:

public interface IWrapper {
    String helloWorld();

    int add(int a, int b);
}

Implement the Wrapper Class

Now, create a class that implements the interface. This class will use Javonet to invoke the Python methods behind the scenes:

import com.javonet.sdk.InvocationContext;
import com.javonet.sdk.Javonet;
import com.javonet.sdk.RuntimeContext;

public class Wrapper implements IWrapper {
    private InvocationContext invocationContext;

    public Wrapper() {
        RuntimeContext runtimeContext = Javonet.inMemory().python();

        runtimeContext.loadLibrary("your-python-files-path");

        invocationContext = runtimeContext.getType("MyClass.MyClass").execute();
    }

    @Override
    public String helloWorld() {
        InvocationContext helloWorld = invocationContext
                .invokeInstanceMethod("hello_world", invocationContext)
                .execute();
        return (String) helloWorld.getValue();
    }

    @Override
    public int add(int a, int b) {
        InvocationContext addResult = invocationContext
                .invokeInstanceMethod("add", invocationContext, a, b)
                .execute();
        return (Integer) addResult.getValue();
    }

}

Build the Program Entry Point

Finally, create a Program class that will initialize Javonet, create an instance of your wrapper, and invoke its methods to demonstrate everything works:

import com.javonet.sdk.Javonet;

public class Program {
  public static void main(String[] args) {
    Javonet.activate("your-license-key");

    System.out.println("Hello, World from JAVA code!!");

    Wrapper wrapper = new Wrapper();

    System.out.println(wrapper.helloWorld());
    System.out.println("Adding result from Python code: " + wrapper.add(5, 9));
    }
}

[!NOTE]
As with any real-world project, you might want to place the Javonet activation and runtime initialization in a more centralized location depending on your application's architecture.

Wrapping the Python Class for Node.js

For Node.js, the structure is slightly simpler compared to .NET and Java.
We will organize our solution into two files:

A wrapper.js file containing the wrapper class and all necessary logic.
A client.js file serving as the entry point to run and test the solution.

Let's walk through the structure:

Install packages

The first step is to add Javonet to your project by installing the required npm packages.
Simply run the following command to include Javonet in your project dependencies:

npm install javonet-nodejs-sdk

and:

npm install javonet-binaries

Create the Wrapper File

First, create a wrapper.js file that defines a class wrapping the Python functionality.
This class will:

Initialize the Javonet runtime.
Load the Python library.
Create an instance of the Python class.
Implement methods that internally delegate calls to the Python object.

const { Javonet } = require('javonet-nodejs-sdk');

class Wrapper {
  constructor() {
    const runtimeContext = Javonet.inMemory().python();

    runtimeContext.loadLibrary("your-python-files-path");

    this.invocationContext = runtimeContext
      .getType("MyClass.MyClass")
      .execute();
  }

  helloWorld() {
    const result = this.invocationContext
      .invokeInstanceMethod("hello_world", this.invocationContext)
      .execute();

    return result.getValue();
  }

  add(a, b) {
    const result = this.invocationContext
      .invokeInstanceMethod("add", this.invocationContext, a, b)
      .execute();

    return result.getValue();
  }
}

module.exports = Wrapper;

Create the Client File

Next, create a client.js file that will serve as the main entry point for your application.
This file will:

Require the wrapper.js module.
Activate Javonet
Instantiate the wrapper class.
Call its methods and display the results.

const {Javonet} = require('javonet-nodejs-sdk')
const Wrapper = require('./wrapper');

Javonet.activate("your-license-key");

console.log("Hello, World from NODEJS!!");

const wrapper = new Wrapper();

console.log(wrapper.helloWorld());
console.log("add(5, 7): ", wrapper.add(5, 7));

[!NOTE]
In a production-ready application, you might want to structure the initialization and runtime activation more cleanly, possibly separating configuration and runtime setup into a dedicated module.

Conclusion

As you can see, Javonet makes it incredibly easy to bridge your code with other technology stacks. By creating simple, native wrappers, you can seamlessly integrate your logic into external applications, without rewriting or reimplementing your core business functionality.

This approach not only boosts code reuse and consistency across platforms, but also allows teams to innovate faster by combining the strengths of different technologies in a clean, maintainable way.

Seamless Unit Testing Across Technologies - Running Python Tests from .NET Web API

Javonet — Wed, 14 May 2025 13:07:34 +0000

Introduction

Modern applications often consist of multiple components written in different technologies. Companies using microservices, multi-layered systems, or external integrations face the challenge of testing business logic spread across various environments.

Standard approaches require either running unit tests separately for each technology or simulating application behavior by mocking its functionality. However, such methods do not always provide a complete picture of the system's actual operation.

With Javonet, it is possible to directly invoke classes from one technology within another and test them as an integral part of the system. This means that unit tests executed for the API can verify the actual behavior of individual components instead of relying on mocked responses.

This solution has many practical applications:

Enables full integration testing – instead of mocking external systems, they can be executed and their behavior can be verified.
Increases test coverage and facilitates diagnostics – by allowing real interactions between system components.
In this article, we will discuss how to set up unit tests in .NET Web API that execute Python classes using Javonet.

Activating Javonet

If you haven't installed Javonet yet, here are the exact instructions for .NET.

Sample Python code

In the first step, let's create and save a very simple Python class:

class Calculator:
    __type__ = "Calculator"

    def add(self, a: int, b: int):
        return a + b

.NET Web API

Due to some technical limitations of Javonet we have to use classic Main() structure of Program.cs

Next, we need to create a .NET Web API, install the Javonet.Netcore.Sdk NuGet package, and pass your Javonet API key. Our Program.cs file should look like this:

namespace WebAppPyTests
{
    using Javonet.Netcore.Sdk;

    internal class Program
    {
        private static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            builder.Services.AddControllers();
            builder.Services.AddOpenApi();

            Javonet.Activate("your-API-key"); // <= pass your API key

            var app = builder.Build();

            if (app.Environment.IsDevelopment())
            {
                app.MapOpenApi();
            }

            app.UseHttpsRedirection();
            app.UseAuthorization();
            app.MapControllers();

            app.Run();
        }
    }
}

API Code

Now, we have to add some controller:

namespace WebAppPyTests.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using Javonet.Netcore.Sdk;

    [ApiController]
    [Route("[controller]")]
    public class CalculatorController : ControllerBase
    {
        [HttpGet("adding")]
        public async Task<ActionResult<int>> GetResult([FromQuery] int a, [FromQuery] int b)
        {
            var pythonRuntime = Javonet.InMemory().Python();

            pythonRuntime.LoadLibrary(@"C:\coding\python\Calculator");
            var calc = pythonRuntime.GetType("calculator.Calculator").Execute();
            var result = calc.InvokeInstanceMethod("add", calc, a, b).Execute();
            var value = (int)result.GetValue();

            return Ok(value);
        }
    }
}

At this stage, we can test our endpoint by calling /calculator/adding?a=5&b=7. We should get 12 as a result.

Unit tests

Now, we can create another project in our solution – an xUnit Test Project – and add our API project as a reference. Our test class can perform Unit Tests on the Python code that we've created before (remember to use your Javonet API key in the constructor):

namespace WebAppPyTests.Tests
{
    using WebAppPyTests.Controllers;
    using Microsoft.AspNetCore.Mvc;
    using Javonet.Netcore.Sdk;
    using System.Threading.Tasks;

    public class JavonetTests
    {
        private readonly CalculatorController _sut;

        public JavonetTests()
        {
            Javonet.Activate("your-API-key");

            _sut = new CalculatorController();
        }

        [Fact]
        public async Task GetResult_ReturnsOkResult()
        {
            // Act
            var result = await _sut.GetResult(2, 4);

            // Assert
            Assert.IsAssignableFrom<ActionResult<int>>(result);
            Assert.NotNull(result);
            Assert.NotNull(result?.Value);
        }

        [Fact]
        public async Task GetResult_ReturnsCorrectResult()
        {
            // Act
            var result = await _sut.GetResult(2, 4);

            var okResult = Assert.IsType<OkObjectResult>(result.Result);
            var actualValue = Assert.IsType<int>(okResult.Value);

            // Assert
            Assert.Equal(6, actualValue);
        }
    }
}

Conclusion

In this article, we explored how to integrate and test Python classes directly from a .NET Web API using Javonet. By leveraging this approach, developers can execute Python logic as a native part of their .NET system, eliminating the need for external service calls or extensive mocking.
This solution enhances test coverage, enables full integration testing, and simplifies debugging in multi-language environments. By incorporating Javonet, developers can ensure smoother interoperability between .NET and Python while maintaining high testing standards.

Create a Smart Java Chatbot Using Python’s ChatterBot – No APIs Needed

Javonet — Thu, 24 Apr 2025 09:42:17 +0000

Introduction

Creating conversational applications doesn’t always require heavyweight AI models or external cloud services. Sometimes, simplicity, speed, and local control are exactly what a project needs — especially when you're working on an MVP, a desktop app, or a lightweight internal tool. If you’re a Java developer looking to add chatbot functionality to your application without leaving the comfort of your Java stack, you might assume you need to build everything from scratch or rely on external APIs.

But what if you could embed a full chatbot engine directly into your Java app — powered by Python — without spinning up any separate servers or services?

In this article, we’ll show how to build a chatbot system in Java, using Python’s ChatterBot library as the conversation engine. By leveraging Javonet, a cross-language bridge that allows direct method calls between Java and Python (or other programming languages), you can:

Keep your business logic and UI in Java
Offload the conversation engine to Python and reuse powerful libraries like ChatterBot
Avoid the complexity of REST APIs or inter-process communication
Run everything in-process and locally, improving speed and simplifying deployment

ChatterBot offers a rule-based, trainable chatbot that can be initialized quickly, trained on your own corpus, and deliver meaningful responses out of the box. And thanks to Javonet, integrating it into a Java application is as simple as calling a method — no wrappers, no containers.

This hybrid approach gives you the best of both worlds: Java’s enterprise-grade structure combined with Python’s rapid AI prototyping capabilities — all without compromising performance or maintainability.

Requirements

All Python packages need to be installed globally, not in a virtual environment!

For our example we used Python 3.12.

ChatterBot packege can be installed by:

pip install chatterbot

You also may need to download en_core_web_sm, which is a trained pipeline for English. Download it by running this command:

python -m spacy download en_core_web_sm

For more information see the ChatterBot GitHub's page.

Sample Python App

To test the installation you can run simple Python code:

from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer

chatbot = ChatBot('Ron Obvious')

# Create a new trainer for the chatbot
trainer = ChatterBotCorpusTrainer(chatbot)

# Train the chatbot based on the english corpus
trainer.train("chatterbot.corpus.english")

# Get a response to an input statement
print(chatbot.get_response("Hello, how are you today?"))

Java code

Now we can reproduce the above code in Java. Create a new Maven project. Your pom.xml file should look like this:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.chatbot</groupId>
  <artifactId>chatbot</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>chatbot.client</name>
  <description>test</description>

  <dependencies>
    <dependency>
      <groupId>com.javonet</groupId>
      <artifactId>javonet-java-sdk</artifactId>
      <version>2.5.14</version>
    </dependency>
  </dependencies>

</project>

Now we can create a simple main() method. The first thing we need to do is activate Javonet and create a Python runtime:

Javonet.activate("your-license-key");
RuntimeContext pythonRuntime = Javonet.inMemory().python();

Next, we need to instantiate the ChatterBot class:

InvocationContext botInvocationContext = pythonRuntime.getType("chatterbot.ChatBot");
InvocationContext chatBotInstance = botInvocationContext.createInstance("Ron Obvious").execute();

Next, we should create a trainer, passing the previously created chatbot instance as an argument, and train the chatbot using the English corpus.

InvocationContext trainerInvocationContext = pythonRuntime.getType("chatterbot.trainers.ChatterBotCorpusTrainer");

InvocationContext trainerInstance = trainerInvocationContext.createInstance(chatBotInstance).execute();

trainerInstance.invokeInstanceMethod("train", "chatterbot.corpus.english").execute();

And now we can ask our question:

String question = "Hello, how are you today?";
InvocationContext result = chatBotInstance.invokeInstanceMethod("get_response", question).execute();

ChatterBot doesn't return a simple string, but an instance of the Statement class. That's why we need to extract the response by accessing its text field.

result.getInstanceField("text").execute().getValue();

The final version of our code could look as follows:

Javonet.activate("your-license-key");
RuntimeContext pythonRuntime = Javonet.inMemory().python();

InvocationContext botInvocationContext = pythonRuntime.getType("chatterbot.ChatBot");
InvocationContext chatBotInstance = botInvocationContext.createInstance("Ron Obvious").execute();

InvocationContext trainerInvocationContext = pythonRuntime.getType("chatterbot.trainers.ChatterBotCorpusTrainer");
InvocationContext trainerInstance = trainerInvocationContext.createInstance(chatBotInstance).execute();
trainerInstance.invokeInstanceMethod("train", "chatterbot.corpus.english").execute();

String question = "Hello, how are you today?";
InvocationContext result = chatBotInstance.invokeInstanceMethod("get_response", question).execute();

System.out.println(result.getInstanceField("text").execute().getValue());
System.out.println("this is the end");

Conclusion

In this article, we demonstrated how to bring conversational intelligence into a Java application without reinventing the wheel — by integrating a Python-based chatbot engine powered by ChatterBot. Thanks to Javonet, the entire interaction between Java and Python can happen locally, synchronously, and efficiently, without the need for REST APIs, containers, or messaging queues.

By combining:

Java’s robust ecosystem, where your business logic, user interface, and infrastructure already live,
with Python’s rapid AI tooling, like ChatterBot for rule-based conversation and quick prototyping,

you gain a flexible, extensible architecture — ready for both experimentation and production.

This hybrid approach empowers developers to:

Rapidly test and iterate NLP solutions in Python
Keep core services and systems in Java
And achieve clean, modular separation of concerns with zero overhead

Whether you're building a lightweight assistant, a guided helpdesk bot, or just experimenting with AI inside your enterprise apps — this integration pattern unlocks a new level of productivity for cross-language projects.

Now that your Java application can talk, the next step is up to you: will it answer FAQs, automate scheduling, guide onboarding, or maybe just have fun?

Build Language-Agnostic Plugins and Extensions Effortlessly with Javonet

Javonet — Thu, 10 Apr 2025 09:58:10 +0000

Introduction

Modern applications often thrive on plugin architectures that let third-party developers or end-users extend functionality.ja Traditionally, these plugins must be written in the same language as the host application, or developers resort to clunky workarounds like inter-process calls or web services. This can limit who can contribute and add complexity to your system. What if you could allow plugins in any programming language, all running seamlessly within your app? Javonet makes this possible by enabling direct, in-process communication between different runtimes (Javonet - The Universal Runtime Integration For All Languages ). With Javonet, a host application can treat modules written in Python, .NET, Ruby, or other languages as if they were native, unlocking endless possibilities without the need for separate services.

In this article, we’ll explore how Javonet empowers a language-agnostic plugin architecture. We’ll use a real-world scenario of a Node.js application loading plugins written in Python, Ruby, and .NET. You’ll see simple code snippets for registering and invoking these plugins dynamically, and learn the technical advantages of Javonet’s cross-language interoperability for building flexible, customizable systems.

Why Allow Plugins in Any Language?

Allowing plugins in multiple languages isn’t just a novelty—it offers tangible benefits for both you and your developer community:

Developer Freedom: Third-party developers can write extensions in the language they know best. A data scientist could contribute a Python plugin, while a systems integrator might prefer C# or Ruby. This lowers the barrier to entry and encourages more contributions.
Leverage Existing Libraries: With a language-agnostic approach, you can tap into a vast ecosystem of libraries across languages. For example, reuse a Python machine learning module or a .NET encryption library directly in your Node.js app, instead of rewriting those features from scratch.
Time and Cost Savings: There’s no need to reimplement or port code between languages. By borrowing proven code (e.g. using a well-tested Python function in a .NET app), you save development time and reduce bugs.
Native Performance, Minimal Overhead: Javonet runs everything within one process, so calls between your host app and the plugin code execute with native speed . Unlike calling external scripts or web APIs, there’s virtually no communication lag since “the whole communication is done in a single OS process”. This means your plugins, regardless of language, behave like first-class citizens in your app’s runtime.
Enhanced Flexibility: A polyglot plugin architecture future-proofs your application. You can choose the best language for each task (e.g. Python for AI, .NET for hardware integration, Ruby for scripting) and mix them in one system. Javonet takes care of marshalling data and managing runtimes, so you focus on functionality.

Scenario: Node.js Host with Multi-Language Plugins

To make this concrete, imagine you’re building a Node.js application—say a developer tool or an automation server—that supports plugins. Normally, you’d implement a JavaScript-based plugin API. But with Javonet, you can allow plugin modules written in Python, Ruby, .NET, or other supported languages to plug into your Node app just as easily. This means end-users of your app can write extensions in the language they’re most comfortable with, and your host application can invoke those extensions seamlessly at runtime.

(Javonet - What is Javonet: The Universal runtime integration) Figure: Javonet bridges your application with modules in various languages within the same process. In our case, a Node.js host (left) can load plugins from Python, .NET, Ruby, and more (right) via Javonet’s runtime bridging technology.

How might this work in practice? You could define a simple plugin interface (for example, each plugin exposes a function like perform_task(input) that returns a result). Third-party developers create plugins following this convention in their language of choice. Your Node.js app will discover plugin files (perhaps by a folder scan) and use Javonet to load and execute each one accordingly. Javonet handles spinning up the appropriate runtime (Python interpreter, .NET CLR, Ruby VM, etc.) inside your process and lets you call into it directly. You don't have to worry about launching separate processes or dealing with serialization—just call the plugin method and get results back.

Let’s walk through a few examples of invoking plugins in different languages from a Node.js host. For brevity, we’ll assume each plugin is already implemented and focus on the Node.js side of things.

Example: Node.js Invoking a Python Plugin

Suppose one plugin is provided as a Python script plugin_math.py with a function perform_task(x) that, say, computes a result (e.g. multiplies x by 2). With Javonet, our Node.js code can call this Python function as if it were a local module:

const { Javonet } = require('javonet-nodejs-sdk');

// Activate Javonet (once at application startup)
Javonet.activate("your-license-key");  // Use your Javonet license key ([How to use PyJokes in Other Programming Languages?! - Javonet](https://www.javonet.com/how-to-use-pyjokes-in-other-programming-languages/?utm_source=devto&utm_medium=article&utm_campaign=INTERNAL_EDUCATIONAL_CONTENT+&utm_content=language_agnostic_plugins))

// Create a runtime context for Python
let pythonRuntime = Javonet.inMemory().python();  // Spin up Python inside Node

// Load the Python plugin script (ensure the directory or file is accessible)
pythonRuntime.loadLibrary("./plugins");  // e.g. directory containing plugin_math.py

// Get a reference to the Python module (plugin) and call its function
let pluginModule = pythonRuntime.getType("plugin_math").execute();  
let result = pluginModule.invokeStaticMethod("perform_task", 5).execute();

// Retrieve the result value and use it in Node
console.log("Python plugin result:", result.getValue());

What’s happening?

Javonet is initialized and activated – This makes the Javonet bridge ready to use.
A Python runtime is started in-process – Javonet.inMemory().python() launches the Python interpreter within the Node.js process, no separate Python process needed.
The plugin module is loaded – We call loadLibrary on the folder (or specific file) where plugin_math.py resides, so Python can import it. Then getType("plugin_math") obtains the Python module by name.
The perform_task function is invoked natively – Using invokeStaticMethod, we call the function perform_task defined in the Python module, passing in an argument (5 in this example). Javonet executes this function inside the Python runtime and returns the result to Node.js as a Javonet result object.
Result is retrieved seamlessly – We call .getValue() on the result to get the actual Python return value (e.g. 10 if the function doubled the input) back into a JavaScript variable. From Node’s perspective, it’s as if a local function was called – Javonet handles all cross-language marshalling under the hood.

The beauty here is that our Node application didn’t need to know how Python executed the code. We didn’t have to shell out to a Python process or expose a web API; Javonet handled the integration invisibly, right in memory.

Example: Node.js Invoking a .NET Plugin

Now consider another plugin delivered as a compiled .NET class library (DLL) named PluginLibrary.dll. This library might contain a class Calculator with a static method PerformTask(int x) that performs some calculation. Even though Node.js isn’t native to .NET, Javonet lets us load that DLL and call its methods easily:

// (Assuming Javonet is already activated as shown earlier)

// Create a runtime context for .NET
let dotnetRuntime = Javonet.inMemory().netcore();  // Launch .NET Core CLR in Node process

// Load the .NET plugin assembly
dotnetRuntime.loadLibrary("./plugins/PluginLibrary.dll"); 

// Get the plugin class type from the assembly (namespace and class name as string)
let pluginClass = dotnetRuntime.getType("MyPlugins.Calculator").execute();

// Invoke the static method 'PerformTask' on the .NET class with an argument
let result = pluginClass.invokeStaticMethod("PerformTask", 5).execute();

console.log(".NET plugin result:", result.getValue());

In this snippet, the Node.js host spins up the .NET Core runtime (netcore) within the same process and loads the PluginLibrary.dll. By obtaining the Calculator class type, we can directly invoke its static method PerformTask(5). Under the hood, Javonet ensures that the .NET CLR executes Calculator.PerformTask and then gives us the return value in JavaScript. The call is synchronous and straightforward – no COM interop or web service glue required. The .NET code runs with full fidelity (including any .NET-specific behaviors or dependencies) next to our Node code. This approach is far simpler and faster than alternatives like spawning a separate .NET process or using a REST API to communicate with a .NET service.

Example: Node.js Invoking a Ruby Plugin

For a third example, let's say an end-user writes a Ruby plugin string_plugin.rb that provides a function to manipulate strings. For instance, it defines a module StringPlugin with a method perform_task(str) that returns a modified version of the input string. Using Javonet, our Node app can execute this Ruby code on the fly:

// Create a runtime context for Ruby
let rubyRuntime = Javonet.inMemory().ruby();  // Embed the Ruby interpreter

// Load the Ruby plugin script
rubyRuntime.loadLibrary("./plugins/string_plugin.rb");

// Get the Ruby module (acts like a class/type in Javonet)
let pluginModule = rubyRuntime.getType("StringPlugin").execute();

// Call the Ruby module's method and get the result
let result = pluginModule.invokeStaticMethod("perform_task", "Hello from Node").execute();

console.log("Ruby plugin result:", result.getValue());

Here we initialize a Ruby runtime in-memory and load the Ruby script file. By naming the Ruby module (StringPlugin), we fetch that module as an object, then invoke its perform_task method with a string argument. Javonet takes care of running the Ruby method within the embedded Ruby VM and converting the return value back to a JavaScript string. The Node app can then continue using that result as if it came from any normal JS function.

Despite calling into three different languages (Python, .NET, Ruby), the pattern in Node.js was very similar each time:

Activate Javonet once (the bridge is ready).
Create a runtime context for the target language (python(), netcore(), or ruby()).
Load the plugin code (script file or assembly).
Get a reference to the plugin’s class or module.
Invoke the desired function/method and retrieve the result.

Javonet’s fluent API makes cross-language calls feel uniform, so you don’t have to learn different integration mechanisms for each language. The called runtime remains loaded, meaning if you invoke multiple plugin methods (or keep plugin objects around), they execute without reinitializing the interpreter each time. You could even maintain state in the foreign runtime if needed (for example, instantiating a Python class and calling methods on it repeatedly).

Technical Advantages of Javonet for Cross-Language Plugins

Using Javonet for a multi-language plugin system isn’t just convenient—it’s technically robust:

In-Process Execution: All integrations happen in one process. Your Node.js host and the Python/Ruby/.NET runtimes run side by side in memory (What the Javonet Runtime Bridging is? | by Javonet | Medium). There’s no IPC overhead, no sockets or HTTP calls. This yields near-native performance for plugin calls and eliminates the complexity of managing extra processes.
Memory & Type Safety: Javonet handles data conversion between languages. For instance, it will map a Python number or .NET integer to a JavaScript number for you. Complex return types (like objects or arrays) are wrapped in Javonet’s context so you can further interact with them if needed. This abstraction ensures you don’t mis-handle memory or types—Javonet manages references across runtimes safely.
Minimal Footprint on Host Code: As shown, invoking a plugin is just a few lines of code. You don’t need to write or maintain any language-specific bridging logic or use FFI libraries; Javonet’s SDK provides a unified way to call anything. This means less maintenance and a cleaner architecture for your host application.
Multi-Platform Support: Javonet works on Windows, Linux, and macOS, so your cross-language plugins are not tied to one OS (Javonet - The Universal Runtime Integration For All Languages ). For example, your Node.js app on Linux can still load a .NET Core plugin (since .NET Core is cross-platform) or a Python plugin, etc. Javonet abstracts the platform differences for you.
Scalability with Remote Plugins: While our focus is in-process plugins, Javonet also offers a gateway to call remote runtimes (over TCP) with the same code if needed. This means you could scale out certain plugins to microservices without changing your integration code. You have the flexibility to choose in-memory or remote execution as appropriate, with Javonet handling the details.

By using Javonet as the backbone of your plugin system, you get a robust interoperability layer that has been optimized for performance and reliability. The result is a plugin architecture that is extremely flexible but doesn’t sacrifice speed or simplicity.

Conclusion

In this article, we demonstrated how Javonet enables a truly language-agnostic plugin architecture. Our Node.js host application was able to load and execute plugins written in Python, .NET, and Ruby with minimal effort. We simply activated Javonet and made cross-language calls directly as if all the code was originally written for Node. The third-party developers or users writing plugins don’t need to learn a new language or deal with complex APIs—they can contribute in the environment they’re productive in, be it writing a quick Python script or leveraging an existing .NET library.

By leveraging Javonet’s runtime bridging, you can seamlessly combine different programming languages in one project, “without the need for web services or complicated setups”. This not only speeds up development and integration, but also opens the door for creative extensions to your software. Imagine the possibilities: your application can be extended by anyone, whether they’re a C# guru, a Python enthusiast, or a Ruby hacker.

So go ahead—empower your users to extend your application in their preferred language. With Javonet handling the heavy lifting of interoperability, you can focus on designing a great plugin API and let developers run wild with it. The end result is a richer, more versatile system that welcomes contributions from across the programming world, truly breaking free from language barriers.

Use Python Built-Ins in Other Languages Effortlessly with Javonet

Javonet — Mon, 07 Apr 2025 07:16:58 +0000

Introduction

Python is famous for its batteries-included philosophy, offering a vast standard library with tools for everything from file manipulation to data processing and web scraping. But what if you’re working in another language like Node.js, .NET, or Ruby and want to leverage Python’s built-in features without rewriting them in your native stack?

While many developers think the only way to use Python’s power is by calling Python scripts from their main language, there’s a much better approach—Javonet. Instead of simply invoking Python externally, why not integrate Python’s built-ins as first-class citizens inside your language of choice? With Javonet, you can directly use Python’s built-in functions, modules, and utilities within other languages, treating them as native capabilities.

This article explores how to extend your applications beyond their default capabilities by leveraging Python’s built-ins in Node.js, .NET, and Ruby—not just as external scripts but as fully integrated tools inside your main project.

Why Use Python’s Built-Ins Instead of Rewriting Functionality?

Each programming language has strengths, but Python’s built-in modules provide a massive head start. Instead of reimplementing common features, developers can borrow Python’s capabilities and make them seamlessly available in their main language. Here’s why you might want to do this:

Time Savings – Instead of rewriting logic for string manipulation, OS operations, or working with dates, just use Python’s standard library.
Performance – Python’s built-ins are optimized and well-tested, making them efficient to use.
Portability – Using a cross-language approach ensures you get consistent results across platforms.
Leverage Python’s Community – Python’s built-ins are frequently updated and improved by a global developer community.

With Javonet, you can use these built-in functions from your primary language without needing Python installed separately or setting up REST APIs to communicate between languages.

Using Python’s Built-Ins in Node.js

JavaScript is great for web applications but lacks some robust built-ins for file handling, system operations, and mathematical functions. Python’s standard library, however, has tools for these tasks, and Javonet allows you to use them inside your Node.js application natively.

Example: Using Python’s `math` Module in Node.js

Let’s say you need precise mathematical operations beyond JavaScript’s standard Math object. Instead of implementing custom logic, why not use Python’s built-in math module inside Node.js?

const { Javonet } = require('javonet-nodejs-sdk');

Javonet.activate("your-license-key");
let pythonRuntime = Javonet.inMemory().python();

let mathModule = pythonRuntime.getType("math").execute();
let sqrtResult = mathModule.invokeStaticMethod("sqrt", 49).execute();

console.log("Square root of 49 using Python’s math module:", sqrtResult.getValue());

What’s Happening?

Node.js instantiates Python’s runtime through Javonet.
The math module is loaded directly within the Node.js app.
The sqrt function is called natively inside Node, returning the result as if it were a native JS function.

Why is this better?

Instead of relying on third-party math libraries in JavaScript, you get Python’s trusted math functions inside your app with zero hassle.

Using Python’s Built-Ins in .NET (C# and VB.NET)

.NET is powerful, but sometimes Python’s built-ins provide additional utilities that may be useful. Instead of reinventing functionality, C# and VB.NET developers can tap into Python’s standard modules without creating separate Python services.

Example: Using Python’s `random` Module in .NET

Python’s random module provides flexible random number generation, which can be useful in C# applications. Let’s call Python’s random module directly in .NET:

namespace Sample
{
    using Javonet.Netcore.Sdk;

    internal class Program
    {
        private static void Main(string[] args)
        {
            Javonet.Activate("your-license-key");
            var pythonRuntime = Javonet.InMemory().Python();

            var randomModule = pythonRuntime.GetType("random").Execute();
            var randomNumber = randomModule.InvokeStaticMethod("randint", 1, 100).Execute();

            Console.WriteLine("Random number between 1 and 100 using Python’s random module:", randomNumber.GetValue());
        }
    }
}

Benefits

Utilize Python’s robust random number generation in C#.
No need to implement custom RNG logic in .NET.

Using Python’s Built-Ins in Ruby

Ruby has a passionate developer base but lacks some built-in functionality available in Python. By integrating Python’s modules into Ruby, you can extend Ruby’s capabilities effortlessly.

Example: Using Python’s `os` Module in Ruby

Python’s os module provides system utilities that Ruby developers often need. Let’s use it in Ruby through Javonet:

require 'javonet-ruby-sdk'

Javonet.activate("your-license-key")
python_runtime = Javonet.in_memory.python

os_module = python_runtime.get_type("os").execute
current_directory = os_module.invoke_static_method("getcwd").execute

puts "Current directory (from Python’s os module): #{current_directory.get_value}"

Why This Matters

Ruby doesn’t need to reimplement system utilities—just borrow them from Python.
Cross-platform compatibility: Python’s OS module handles Windows, Linux, and macOS differences automatically.
Lightweight: No subprocesses, just direct integration.

Expanding Beyond Built-Ins: Using Python’s Ecosystem

While Python’s built-ins are incredibly useful, Javonet also enables access to third-party libraries in other languages. This means:

AI and ML models (e.g., PyTorch, TensorFlow) can be called from C# or JavaScript.
Data visualization tools (e.g., Matplotlib, Folium) can be embedded in non-Python applications.
Scientific computing (e.g., NumPy, SciPy) can enhance Ruby and .NET apps.

Conclusion: The Future of Multi-Language Development

Javonet redefines cross-language programming by allowing you to use Python’s built-in features inside any major programming language without complex APIs, subprocesses, or rewrites. Instead of reinventing the wheel, you can simply extend your primary language with Python’s rich functionality.

🚀 Why limit yourself to just one language when you can have the best of all worlds?

Next time you need to process dates, run calculations, handle system operations, or anything else—don’t rewrite it, just integrate it. Javonet makes it effortless. Happy coding! 🚀

Say mooo in Every Programming Language with Cowsay!

Javonet — Thu, 20 Feb 2025 21:27:02 +0000

Abstract

Dive into the whimsical world of cowsay—a command-line program that turns plain text into moo-ving masterpieces voiced by an ASCII cow! In this article, we’ll journey through cowsay’s quirky origins, explore its evolution across various programming languages, and reveal how you can effortlessly integrate the Python version of Cowsay into your projects using Javonet.

The Origin Story of Cowsay

Back in the late 90s, developer Tony Monroe decided that the bland command line needed some personality. And thus, cowsay was born! This clever tool transforms any text into an adorable message delivered by an ASCII cow. Originally a playful experiment, cowsay quickly became a cult classic among programmers and Linux enthusiasts, finding its way into scripts, system messages, and geeky jokes everywhere. Thanks to its open-source nature, countless adaptations have emerged, each adding fresh twists to keep cowsay moo-ving along in hacker culture.

Cowsay Today: A Classic with a Modern Twist

Even decades later, cowsay remains a beloved staple in the developer community. What began as a Perl script has since been reimagined in languages like Python, Go, JavaScript, and more. Whether you're working on Windows, building web apps, or coding chatbots, you can always count on cowsay to inject a bit of humor into your day. Not only does it celebrate nostalgia, but its endless variations—ranging from penguins to dragons—showcase its enduring charm.

The Python cowsay available on PyPI brings that playful moo to your Python scripts. Meanwhile, Neo Cowsay in Go offers speed and extra features, and JavaScript/Node.js and Ruby variants allow enthusiasts from different communities to join in the fun. One standout is the JavaScript implementation by piuccio, which has already collected over 1.2k stars on GitHub! Check it out here.

Integration Made Easy with Javonet

Why rewrite the same functionality in every language when you can simply share the magic? Enter Javonet—a tool that lets you call the Python implementation of cowsay directly from other languages. Imagine having the original Python cowsay as your source of moo magic, available at your fingertips in Node.js, Ruby, Java, and beyond. With Javonet, integrating this playful utility is as easy as pie (or should we say, moo?).

Python Cowsay

The Python version of cowsay is delightfully simple. Install it via pip:

pip install cowsay

Then, use it in your Python script:

import cowsay

cowsay.cow('Hello World')

This produces:

 ___________
| Hello World |
  ===========
           \
            \
              ^__^
              (oo)\_______
              (__)\       )\/\
                  ||----w |
                  ||     ||

Javonet in Action

Using Javonet, you can effortlessly harness the power of Python's cowsay in your language of choice. This way, you avoid reinventing the wheel and can enjoy the same moo magic across multiple platforms.

Node.js Example

First, install the Javonet Node.js SDK:

npm i javonet-nodejs-sdk

Assuming you have Python and its cowsay module installed, here’s a simple Node.js example:

const { Javonet } = require('javonet-nodejs-sdk');

Javonet.activate("javonet-key");

let calledRuntime = Javonet.inMemory().python();
calledRuntime.loadLibrary('.');

let calledRuntimeType = calledRuntime.getType("cowsay").execute();

let response = calledRuntimeType.invokeStaticMethod("I am mooo in NodeJs with Python's Cowsay!!!", "sad").execute();

let result = response.getValue();
console.log(result);

The output will display the cowsay result in your Node.js application:

 ___________________________________________
| I am mooo in NodeJs with Python's Cowsay!!! |
  =========================================
                                           \
                                            \
                                              ^__^
                                              (oo)\_______
                                              (__)\       )\/\
                                                  ||----w |
                                                  ||     ||

Ruby Example

To integrate with Ruby, first install the Javonet Ruby SDK:

gem install javonet-ruby-sdk

Then, use it as follows:

require 'javonet-ruby-sdk'

Javonet.activate("javonet-key")

calledRuntime = Javonet.in_memory.python
calledRuntime.load_library('.')

calledRuntimeType = calledRuntime.get_type("cowsay").execute

response = calledRuntimeType.invoke_static_method("cow", "I am mooo in Ruby with Python's Cowsay!!!").execute
result = response.get_value
puts result

Expected output:

 _________________________________________
| I am mooo in Ruby with Python's Cowsay!!! |
  =========================================
                                         \
                                          \
                                            ^__^
                                            (oo)\_______
                                            (__)\       )\/\
                                                ||----w |
                                                ||     ||

Java Example

Finally, to integrate in Java, first download Javonet (using Maven is recommended) and add it to your dependencies. Then, compile and run your program:

mvn compile
mvn exec:java -Dexec.mainClass="SampleProgram"

Here’s a sample Java program:

import com.javonet.sdk.*;

public class SampleProgram {
    public static void main(String[] args) {
        Javonet.activate("javonet-key");

        RuntimeContext pythonRuntime = Javonet.inMemory().python();

        InvocationContext pythonType = pythonRuntime.getType("cowsay").execute();

        InvocationContext response = pythonType.invokeStaticMethod("cow", "I am mooo in Java with Python's Cowsay!!!").execute();

        String result = (String) response.getValue();
        System.out.println(result);
    }
}

A typical output will be:

 _________________________________________
| I am mooo in Java with Python's Cowsay!!! |
  =========================================
                                         \
                                          \
                                            ^__^
                                            (oo)\_______
                                            (__)\       )\/\
                                                ||----w |
                                                ||     ||

Wrapping Up

By harnessing Javonet, you can effortlessly integrate Python's charming cowsay into a myriad of programming environments without reinventing the wheel. This not only preserves the original magic but also exemplifies the flexibility and efficiency of modern development tools. With minimal extra effort, you can now "say mooo" in your language of choice.

So next time you want to add a dash of humor to your code, remember the humble ASCII cow that continues to inspire developers around the world. Happy coding and keep mooing!

Enjoy integrating a little moo magic into your projects—after all, a playful touch can make even the most serious code a lot more interesting!

Mastering .NET Interoperability: Connecting .NET Framework and .NET Core with Javonet

Javonet — Mon, 10 Feb 2025 12:38:02 +0000

Introduction

As technology evolves, developers often face the challenge of integrating legacy systems with modern platforms. One of the most common scenarios is bridging the gap between applications built using the .NET Framework and those leveraging the latest advancements in new .NET Core and .NET solutions.

Learn more about .NET and .NET Core at Microsoft .NET Docs.
Learn more about .NET Framework at Microsoft .NET Framework Docs

The .NET Framework, with its rich history and extensive library support, continues to power countless enterprise solutions. However, as organizations embrace the performance, scalability, and cross-platform benefits of .NET Core and its successors, the need for seamless interoperability becomes critical.

This is where Javonet comes into play. Javonet provides a powerful solution to enable direct communication between those two technologies, eliminating the complexities and inefficiencies of traditional integration approaches. Whether you're looking to reuse legacy libraries, modernize existing systems, or extend functionality across platforms, Javonet simplifies the process, saving time and effort while maintaining the integrity of your codebase.

In this article, we’ll explore how Javonet enables smooth interaction between .NET Framework and .NET, and why it’s a game-changer for developers seeking to future-proof their applications without rewriting legacy code from scratch. We will show how you can call .NET Framework code from .NET 8 and the other way around (call .NET 8 from .NET Framework).

Activating Javonet

If you haven't installed Javonet yet, here are the exact instructions for .NET Javonet Documentation - .NET Quickstart Guide.

Calling .NET Framework from .NET 8 console application

.NET Framework code

Let's create class library for .NET Framework with 2 classes:

using System;

namespace ClassLibrary
{
    public class TestClass
    {
        public void TestMethod()
        {
            Console.WriteLine("Hello from .NET Framework class!");
        }
    }
}

using System;

namespace ClassLibrary
{
    public static class TestStaticClass
    {
        public static void TestMethod()
        {
            Console.WriteLine("Hello from .NET Framework static class!");
        }
    }
}

We need to build the code and locate the generated DLL file. It should be in the. It should be at /bin/Release/ or /bin/Debug/ directory. In this case, the file will be named ClassLibrary.dll.

.NET 8 code

Now, let's create a .NET 8.0 console app that will call methods created above.

[!NOTE]
Due to some technical limitations of Javonet we have to use classic Main() structure of Program.cs

On the first line, we can add Console.WriteLine() to display the source of the data, activate Javonet, and initialize the .NET Framework runtime:

Console.WriteLine("Hello, World from .NET code!");
Javonet.Activate("your-license-key");
RuntimeContext calledRuntime = Javonet.InMemory().Clr();

In the next step, we need to provide the path to our .NET Framework DLL file.

calledRuntime.LoadLibrary("Your/DLL/File/Path");

Once the runtime is created, we can begin calling methods. To invoke an instance method, we first need to create an instance of the class...

InvocationContext calledRuntimeType = calledRuntime.GetType("ClassLibrary.TestClass").Execute();

... and call a method:

InvocationContext instance = calledRuntimeType.CreateInstance().Execute();
instance.InvokeInstanceMethod("TestMethod").Execute();

For static methods we can use:

InvocationContext calledStaticRuntime = calledRuntime.GetType("ClassLibrary.TestStaticClass").Execute();
calledStaticRuntime.InvokeStaticMethod("TestMethod").Execute();

Our final code may look like below:

namespace JavonetTest
{
    using Javonet.Netcore.Sdk;

    internal class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("Hello from .NET code!");

            Javonet.Activate("your-license-key");

            RuntimeContext calledRuntime = Javonet.InMemory().Clr();

            string libraryPath = "Your/DLL/File/Path";
            string className = "ClassLibrary.TestClass";
            string staticClassName = "ClassLibrary.TestStaticClass";

            // load custom library
            calledRuntime.LoadLibrary(libraryPath);

            // get type from the runtime
            InvocationContext calledRuntimeType = calledRuntime.GetType(className).Execute();

            // invoke instance method
            InvocationContext instance = calledRuntimeType.CreateInstance().Execute();
            instance.InvokeInstanceMethod("TestMethod").Execute();

            // invoke static method
            InvocationContext calledStaticRuntime = calledRuntime.GetType(staticClassName).Execute();
            calledStaticRuntime.InvokeStaticMethod("TestMethod").Execute();
        }
    }
}

After executing this code, the console output should look similar to the example below:

Hello, World from .NET code!
javonet.lic exists. Verifying...  License valid.
Hello from .NET Framework class!
Hello from .NET Framework static class!

Calling .NET 8 app inside docker container from .NET Framework application

The process here will be quite similar. First, we need to create a .NET 8 class library.

.NET 8 code

Let's create 2 classes:

namespace NetCoreClassLibrary
{
    public class TestClass
    {
        public string TestMethod(string name)
        {
            return $"Hello from .NET 8.0 class, {name}!";
        }
    }
}

and:

namespace NetCoreClassLibrary
{
    public static class TestStaticClass
    {
        public static string TestMethod(string name)
        {
            return $"Hello from .NET 8.0 static class, {name}!";
        }
    }
}

.NET Framework code

Our code here has an almost identical structure. However, this time, we need to add an argument to the method invocation. The code might look like this:

using System;

namespace FrameworkConsoleApp
{
    using Javonet.Clr.Sdk;

    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World from .NET Framework code!");

            Javonet.Activate("your-license-key");

            RuntimeContext calledRuntime = Javonet.InMemory().Netcore();

            string libraryPath = "Your/DLL/File/Path";
            string className = "NetCoreClassLibrary.TestClass";
            string staticClassName = "NetCoreClassLibrary.TestStaticClass";

            // load custom library
            calledRuntime.LoadLibrary(libraryPath);

            // get type from the runtime
            InvocationContext calledRuntimeType = calledRuntime.GetType(className).Execute();
            InvocationContext instance = calledRuntimeType.CreateInstance().Execute();
            InvocationContext response = instance.InvokeInstanceMethod("TestMethod", "User").Execute();
            Console.WriteLine(response.GetValue());

            InvocationContext calledRuntimeTypeForStatic = calledRuntime.GetType(staticClassName).Execute();
            InvocationContext staticResponse = calledRuntimeTypeForStatic.InvokeStaticMethod("TestMethod", "User").Execute();
            Console.WriteLine(staticResponse.GetValue());
        }
    }
}

As you can see, we passed an argument to the methods as the second parameter of InvokeInstanceMethod() and InvokeStaticMethod().

Conclusion

Bridging the gap between .NET Framework and .NET Core, including .NET 8, doesn’t have to be a challenge. With Javonet, you can seamlessly integrate legacy code with modern applications, saving time and resources while future-proofing your projects.

Ready to simplify your development process? Try Javonet today and unlock the full potential of your .NET ecosystem!

Create Stunning Maps in Node.js by Integrating Python’s folium with Javonet

Javonet — Fri, 31 Jan 2025 12:03:14 +0000

In this article, we will explore how you can integrate Python’s folium library into a Node.js backend application using Javonet. This setup allows you to leverage Python's powerful libraries for geospatial data and map creation while using Node.js as the server-side framework.

Why Use Python’s `folium` for Interactive Maps?

Ease of Use: Python's folium allows you to create beautiful, interactive maps with minimal effort.
Advanced Features: You can easily create heatmaps, clusters, popups, and more.
Powerful Data Integration: Python integrates seamlessly with data science libraries like geopandas, making it ideal for geospatial analysis.

Scenario: Creating an Enhanced Map

Imagine you are building a logistics system, and you want to display key distribution centers on an interactive map. Python’s folium makes it easy to achieve this, and Javonet allows you to execute Python code within a Node.js environment.

Step 0: Install Dependencies

Before we start, ensure you have the necessary dependencies installed.

Install Python dependencies for generating the map:
```
pip install folium
```

Install Node.js dependencies for using Javonet and Express:

npm init -y
npm install javonet-nodejs-sdk express

Step 1: Create the Map with Python

First, let's write the Python script to generate a map using folium.

map.py

import folium
from folium.plugins import HeatMap, MarkerCluster
import random

def generate_random_points(center, num_points, spread=0.1):
    """Generate random points around a center location."""
    return [
        {
            "lat": center["lat"] + random.uniform(-spread, spread),
            "lon": center["lon"] + random.uniform(-spread, spread),
            "popup": f"Random point {i}"
        }
        for i in range(num_points)
    ]

def create_enhanced_map():
    # Define the center of the map
    center_lat = 37.7749
    center_lon = -122.4194

    # Create a map object with CartoDB Positron tiles
    m = folium.Map(
        location=[center_lat, center_lon],
        zoom_start=6,
        tiles="CartoDB Positron"
    )

    # Main locations for the heatmap and markers
    main_locations = [
        {"lat": 37.7749, "lon": -122.4194, "name": "San Francisco", "popup": "This is San Francisco!"},
        {"lat": 34.0522, "lon": -118.2437, "name": "Los Angeles", "popup": "This is Los Angeles!"},
        {"lat": 40.7128, "lon": -74.0060, "name": "New York", "popup": "This is New York!"}
    ]

    # Generate additional random points around the main locations
    additional_points = []
    for loc in main_locations:
        additional_points.extend(generate_random_points(loc, 33))

    # Combine main locations and additional points
    all_locations = main_locations + additional_points

    # Add a heatmap with enhanced parameters
    heat_data = [[loc["lat"], loc["lon"]] for loc in all_locations]
    HeatMap(heat_data, radius=25, blur=15).add_to(m)

    # Add markers with popups
    marker_cluster = MarkerCluster().add_to(m)
    for loc in all_locations:
        folium.Marker(
            location=[loc["lat"], loc["lon"]],
            popup=loc["popup"],
            icon=folium.Icon(icon="info-sign")
        ).add_to(marker_cluster)

    # Add layer control
    folium.LayerControl().add_to(m)

    # Save the map as an HTML file
    map_file = "enhanced_map.html"
    m.save(map_file)
    return map_file

# Example usage
if __name__ == "__main__":
    print("Map saved to:", create_enhanced_map())

This Python script generates a map centered on California with markers for San Francisco, Los Angeles, and New York, as well as a heatmap and random points scattered around these cities.

Now we need to just call our Python code in Node.js. We can do it by running our ready python script inside Node.js App (Option 1) or we can write Python code nativly (Option 2) in our app thanks to Javonet

Step 2 (Option 1): Run the Python Script from Node.js Using Javonet

Now that the Python script is ready, let’s integrate it into your Node.js application using Javonet.

app.js

const express = require('express');
const path = require('path');
const { Javonet } = require('javonet-nodejs-sdk');  // Import Javonet SDK

const app = express();
const port = 3001;

// Activate Javonet with your license key
Javonet.activate("key"); // Replace with your Javonet license key

// Load the Python runtime and specify the Python library
let calledRuntime = Javonet.inMemory().python();  // Initialize Python runtime
const libraryPath = ".";  // Path to the Python script or library
calledRuntime.loadLibrary(libraryPath);  // Load the library (directory where Python script is located)

// Function to run the Python script using Javonet
async function generateMap() {
    try {
        // Load the Python function `create_enhanced_map` from the Python script
        let pythonScriptType = calledRuntime.getType('map');  // Name of your Python script (without `.py`)

        // Invoke the Python method `create_enhanced_map` from the loaded script
        let response = pythonScriptType.invokeStaticMethod('create_enhanced_map').execute();

        // Get the value (map file path)
        let mapFilePath = response.getValue();

        console.log("Map generated successfully:", mapFilePath);
        return mapFilePath;  // Return the map file path
    } catch (error) {
        console.error("Error running the Python script:", error);
        return null;  // Return null if there was an error
    }
}

// Serve the map when the app is started
app.get('/', async (req, res) => {
    const mapFilePath = await generateMap();

    if (mapFilePath) {
        // Serve the generated map HTML file
        res.sendFile(path.join(__dirname, mapFilePath));  // Path to the generated map
    } else {
        res.status(500).send("Error generating the map.");
    }
});

app.listen(port, () => {
    console.log(`Server is running at http://localhost:${port}`);
});

Step 2 (Option 2): Write Python code in Node.js Using Javonet

To make things easier i wrote simple version of our Python code right here:

import folium

location = [37.7749, -122.4194]

m = folium.Map(location)

marker = folium.Marker(location, "San Francisco")

m.add_child(marker)

m.save("simple_map.html")

So now we can nativly use Python Code in Node app!


const { Javonet } = require('javonet-nodejs-sdk');  // Import Javonet SDK

Javonet.activate("javonet-key"); 

let calledRuntime = Javonet.inMemory().python();
const libraryPath = ".";  
calledRuntime.loadLibrary(libraryPath);  
let folium = calledRuntime.getType('folium').execute()


const location = [37.7749, -122.4194]

let map = folium.invokeStaticMethod("Map", location).execute()
let marker = folium.invokeStaticMethod("Marker", location, "San Francisco").execute()

map.invokeStaticMethod("add_child", marker).execute()
map.invokeStaticMethod("save", "simple.html").execute()

This code will generate simple map with Python in Node.Js!

Step 3: Test the Node.js Application

Start the Node.js server:
```
node app.js
```
Access the map: Visit http://localhost:3001 in your web browser to see the interactive map generated by the Python script.

Here are some examples:

Where to use it?

You can use this functionality to build a custom Node.js app that, with a click (or based on some data), will generate beautiful maps that you can easily interact with :) That's another example of Javonet usage! Feel free to share your ideas about cross-language integrations!

Directory Structure

Your project directory should look like this:

/maps
    ├── map.py  // Python script to generate the map (if option 2 without map.py)
    ├── app.js  // Node.js backend using Javonet

Conclusion

By using Javonet to integrate Python’s folium library into your Node.js application, you can easily generate advanced interactive maps in Python and serve them through your Node.js backend. This approach leverages the strengths of both ecosystems, enabling powerful geospatial data handling with Python and fast web service delivery with Node.js.

Feel free to experiment with different map types and Python libraries to extend your application further!

DEV Community: Javonet

Make ASCII Art Anywhere_ Use Python’s `pyfiglet` in Ruby, .NET Core, and Node.js with Javonet

What Is pyfiglet?

Cross-Language Code with Javonet

Setup Prerequisites

Use pyfiglet in Ruby with Javonet

🔧 Ruby Example

Use pyfiglet in .NET Core (C#) with Javonet

🔧 .NET Core (C#) Example

Use pyfiglet in Node.js with Javonet

🔧 Node.js Example

Going Beyond Hello World

Why It Matters

Final Thoughts

Wrap Once, Run Everywhere_ Integrating Python with .NET, Java, and Node.js using Javonet

Introduction

Wrapping the Python Class for .NET

Install nuget package

Create the Interface

Implement the Wrapper Class

Build the Program Entry Point

Wrapping the Python Class for Java

Edit pom.xml file

Create the Interface

Implement the Wrapper Class

Build the Program Entry Point

Wrapping the Python Class for Node.js

Install packages

Create the Wrapper File

Create the Client File

Conclusion

Write Once, Run Everywhere – Integrating JavaScript with Python, Java and .NET

Introduction

Code samples

Sample Python code

Sample Java code

Sample .NET code

Wrapping the code for Node.js

Install packages

Create the Wrapper File

Create the Client File

Conclusion

How to combine WinForms UI and Python charting in minutes using Javonet.html

Introduction

Prerequisites

.NET (C#/WinForms) side

Python side

Creating the Python Charts Class

Building the WinForms UI in C

Calling Python from C# with Javonet

Designing the MainForm.cs

MainForm.cs – Constructor Overview

Completing the MainForm Constructor

Conclusion

Wrap Once, Run Everywhere_ Integrating Python with .NET, Java, and Node.js using Javonet

Wrap Once, Run Everywhere: Integrating Python with .NET, Java, and Node.js using Javonet

Introduction

Sample Python code

Wrapping the Python Class for .NET

Install nuget package

Create the Interface

Implement the Wrapper Class

Build the Program Entry Point

Wrapping the Python Class for Java

Edit pom.xml file

Create the Interface

Implement the Wrapper Class

Build the Program Entry Point

Wrapping the Python Class for Node.js

Install packages

Create the Wrapper File

Create the Client File

Conclusion

Seamless Unit Testing Across Technologies - Running Python Tests from .NET Web API

Introduction

Activating Javonet

Sample Python code

.NET Web API

API Code

Unit tests

What Is `pyfiglet`?

Use `pyfiglet` in Ruby with Javonet

Use `pyfiglet` in .NET Core (C#) with Javonet

Use `pyfiglet` in Node.js with Javonet

Creating the Python `Charts` Class

Example: Using Python’s `math` Module in Node.js

Example: Using Python’s `random` Module in .NET

Example: Using Python’s `os` Module in Ruby

Why Use Python’s `folium` for Interactive Maps?