inox2d VS manim

I'm writing Inox2D, which is kind of a rewrite of Inochi2D in Rust. The aim is to reach more use-cases such as web with WASM and even potentially embedded development, but at the very least an implementation in a low-level non-garbage-collected language.

Inox2D, an experimental native Rust implementation of Inochi2D.

inox2d - official experimental reimplementation of Inochi2D, an open-source alternative of Live2D for animating 2D puppets in various contexts such as games or vtubing. inox2d isn't really meant to be a replacement over the current implementation, but more of a complementary one that extends it's use-cases, for example embedded devices and web integration with WASM.

Hey, I'm working on inox2d which uses glow.

For example, I wouldn't want to separate this into multiple files, would make it harder to see where all the deserialization logic is.

For example, I'm working on Inox2D, a reimplementation of Inochi2D in Rust.

I absolutely get that. It was actually very clear in a project of mine. I work on inox2d which is a native implementation of Inochi2D in Rust (Inochi2D being a FOSS puppet animation system, like Live2D which is used by vtubers and light novel engines notably).

For example, on my Inox2D project, I was using serde to deserialize some JSON payload. But that came with some hacks I had to do, like have a temporary struct that gets converted to the final one because it wasn't possible to serialize it by itself, and add extra-dependencies to make the system extensible while also supporting external structures I used like Arena from the indextree crate.

You can find it at https://github.com/Inochi2D/inox2d. If you know stuff about OpenGL and low-level rendering in general I'd really appreciate some help as I myself am very new to this stuff.

Also check out community edition: https://www.manim.community

manim – A community-maintained Python framework for creating mathematical animations

I recently wanted to make something similar and I completely fell in love with https://www.manim.community/ created by 3B1B.

https://github.com/gumyr/build123d :

> Build123d is a python-based, parametric, boundary representation (BREP) modeling framework for 2D and 3D CAD. It's built on the Open Cascade geometric kernel and allows for the creation of complex models using a simple and intuitive python syntax. Build123d can be used to create models for 3D printing, CNC machining, laser cutting, and other manufacturing processes. Models can be exported to a wide variety of popular CAD tools such as FreeCAD and SolidWorks.

> Build123d could be considered as an evolution of CadQuery where the somewhat restrictive Fluent API (method chaining) is replaced with stateful context managers* - e.g. with blocks - thus enabling the full python toolbox: for loops, references to objects, object sorting and filtering, etc.*

"Build123d: A Python CAD programming library" (2023) https://news.ycombinator.com/item?id=37576296

BREP: Boundary representation: https://en.wikipedia.org/wiki/Boundary_representation

Manim, Blender, PhysX, o3de, [FEM, CFD, [thermal, fluidic,] engineering]: https://github.com/ManimCommunity/manim/issues/3362

NURBS: Non-Uniform Rational B-Splines: https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline

NURBS for COMPAS: https://github.com/gramaziokohler/compas_nurbs :

> This package is inspired by the NURBS-Python package, however uses a NumPy-based backend for better performance.

> Curve, and Surface are non-uniform non-rational B-Spline geometries (NUBS), RationalCurve, and RationalSurface are non-uniform rational B-Spline Geometries (NURBS). They all built upon the class BSpline. Coordinates have to be in 3D space (x, y, z)

test_curve.py, test_surface.py

https://github.com/compas-dev

compas_rhino, compas_blender

Blender docs > Modeling Surfaces; NURBs implementation, limits, challenges:

A template language that I wrote for generating HTML. Meant to be included as a C++ library. https://github.com/Ghoti-io/Tang

Plenty of other C++ code of mine is on Github (such as a bunch of utility stuff, a thread pool, and a HTTP server that I'm writing from scratch), even though I would only call myself an intermediate C++ programmer. I just happen to like the language.

Or, if I had to throw other stuff into the mix, a fairly recent patch to Manim (Python) that got accepted (https://github.com/ManimCommunity/manim/pull/3155).

If I were really pressed, I would dig up a lot of my Drupal (PHP) stuff that I did years ago.

I would love to have this https://github.com/manimCommunity/manim written in Rust. There have been previous attempts (bevy_manim and another one using nannou) but all of them are outdated