jlang--godot bridge, built in rust

Overview

jlang-rs-gd

J is an extremely high-level mathematical notation and programming language.

Godot is a game / gui / multimedia engine.

jlang-rs-gd lets you call J from godot, using a glue layer built in rust.

requirements

  • rust and cargo (rust is a programming language, cargo is its build tool)
  • clang (the godot bindings need this to build)
  • godot (I use 3.3, but any 3.x should work)
  • j (so you have a j dll to call)

building the dll

The output of the build process is a dll that you need to copy to your Godot project.

Until jlang-rs is somewhat stable, you need a local working copy in a sibling directory (or uncomment the { git = ... } line in Cargo.toml)

cd /path/to/dev/area
git clone https://github.com/tangentstorm/jlang-rs
git clone https://github.com/tangentstorm/jlang-rs-gd
cd jlang-rs-gd

to build jlang_rs_gd.dll:

  • set the LIBCLANG_PATH environment variable
  • run cargo test, cargo build, etc.

examples:

# powershell:
$env:LIBCLANG_PATH="d:/program files/llvm/bin"; cargo test

# git bash:
LIBCLANG_PATH='d:/program files/llvm/bin' cargo test

Running the demo

Once you have a sucessful build:

cp target/debug/jlang_rs_gd.dll demo/
cp j.dll demo/   #  or .so on linux (untested)

The run godot and open the project in the demo/ directory.

Adding the DLL to your own Godot project

This is a slightly tedious, manual process:

  • copy the two DLLs from the above section to your project directory.
  • copy the jlang-rs-gd.tres file from the demo directory, or recreate it from scratch
  • create a GdNative script in godot, using jlang-rs-gd.tres as the
You might also like...
A rust chess implementation using a neural network scoring function built on huggingface/candle + rust + wasm

Rusty Chess What is it? Rusty Chess aims to be a high quality embeddable chess engine that runs entirely locally in the browser (no backend required).

A refreshingly simple data-driven game engine built in Rust

What is Bevy? Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever! WARNING Bevy is still in the ve

game engine built in rust, using wgpu and probably other stuff too

horizon game engine engine for devpty games, made in 99.9% rust and 0.1% shell. this is our main project currently. the engine will be used for most i

Bevy is a refreshingly simple data-driven game engine built in Rust

What is Bevy? Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever! WARNING Bevy is still in the ve

🎮 A Realtime Multiplayer Server/Client Game example built entirely with Rust 🦀

Example of a 🎮 Realtime Multiplayer Web Game Server/Client built entirely using Rust 🦀

General purpose client/server networking library written in Rust, built on top of the QUIC protocol which is implemented by quinn

Overview "This library stinks!" ... "Unless you like durian" durian is a client-server networking library built on top of the QUIC protocol which is i

📺 An implementation of the retro bouncing DVD logo screensaver animation built with bevy and rust
📺 An implementation of the retro bouncing DVD logo screensaver animation built with bevy and rust

📺 Bevy bouncing DVD logo This project is a simple demonstration of using the Bevy game engine and the Rust programming language to create a bouncing

A simple and minimal game engine library built in rust.

Neptune A brand new free, open-source minimal and compact game engine built in rust. Design Goals We plan to make Neptune a small and minimal engine,

A velocity-based falling sand simulation built with Rust and Bevy

⏳ Bevy Falling Sand A velocity-based falling sand simulation built with Rust and Bevy! This simluation uses bevy_rapier to generate colliders that reg

Owner
tangentstorm
tangentstorm
A CLI tool to manage your godot-rust projects

ftw A CLI tool to manage your godot-rust project! Table of contents General Information Setup Usage Contact General Information This is a tool to help

Michael Angelo Calimlim 77 Dec 13, 2022
A tool to generate inbetweens for animated sprites, written in godot-rust

Bitmapflow is a tool to help you generate inbetweens for animated sprites. In other words, it makes your animations smoother. It uses optical flow to

null 411 Dec 21, 2022
An egui backend for godot-rust

Godot Egui An egui backend for godot-rust. Rationale Godot has a perfectly valid GUI system, so why egui? Here are my personal reasons: Simplicity: No

null 109 Jan 4, 2023
An artisanally made PSD Importer for Godot, written in Rust

PSD Importer for Godot Speed up your import workflow ✨ An artisanally made PSD Importer for Godot 3.5, written in Rust. ✨ Getting Started | ?? Documen

Bram Dingelstad 4 Jan 26, 2023
GDDB is a superfast in-memory database designed for use in Godot

GDDB GDDB is a superfast in-memory database designed for use in Godot. This database aims to provide an easy frontend to an efficient in-memory databa

Richard Patching 5 Dec 4, 2022
A Godot 3.4 binding for Live2D

godot-cubism A Godot 3.4 binding for cubism-rs which itself is a binding for the native cubism sdk. Usage var factory = load("path_to_your_native_scri

null 16 Dec 23, 2022
A crate for using Bevy with the Godot Engine.

bevy_godot A crate for using Bevy with the Godot Engine. This crate is in active development and is not ready for production use. Features Godot Scene

Abby Bryant 63 Dec 17, 2022
Plugin to generate flowfields from tilemaps in the Godot Engine!

Godot Tilemap Flowfields RTS-Style optimized path-finding for crowds of agents. Built for the Godot game engine, written with performance in mind in R

Arne Winter 18 Jan 10, 2023
A direct ecs to low-level server implementation for Godot 4.1

godot_ecs What if Godot 4.1 and Bevy got married? Well, you'd get one interesting duo of data driven goodness. In Development This crate is not produc

null 5 Oct 6, 2023
An extendable system made up of autonomous execution services known as nodes organized in a tree of processes. Inspired by Godot!

NodeTree NodeTree is a framework to create large scalable programs and games through a tree of processes. Each process is fully autonomous and is capa

LunaticWyrm 3 Apr 10, 2024