Modern robotics workflows lean heavily on simulation—Gazebo, Mujoco, Isaac Sim, and others—long before a single screw is tightened.
3‑D‑printed components dominate proof‑of‑concept builds because they reduce cost and iteration time, yet we often treat them as massless placeholders in URDF or SDF files.
Neglecting the real mass, center of mass (COM), and inertia tensor may appear harmless, but the error propagates into:

• unstable controllers that seem correct in simulation,
• mis‑tuned balance algorithms in legged or mobile platforms,
• gripper payload limits that differ from reality.

This post introduces PrintDynamic, a small Rust → WASM application that parses G‑code and computes true dynamic parameters of an extruded part. We will explore why the project is written with the Leptos front‑end framework, and how you can integrate it into your own workflow.

Everyone has a desire to customize their tools, and there is no exception when it comes to development setups. One might write flawless, beautiful code using VSCode, but the joy and experience of customizing your coding setup is what led me into this endless journey.

Neovim

The idea of Vim/Neovim can be jarring for many people; navigating through code with only your keyboard seems extremely inefficient. However, the reality is quite the opposite. Being able to navigate, write, and edit text with only your keyboard is one of the greatest blessings Neovim provides. Additionally, everything is rendered on a GPU-accelerated terminal, making it extremely responsive. Many IDEs and text editors use native UI kits, custom UI frameworks, or even worse, Electron. On the other hand, Neovim’s startup is instant—you can’t even notice it loading up.

Navigating the Challenges of #![no-std] in Eerie

The quest for #![no-std] support in Eerie has proven to be more challenging than anticipated, particularly when delving into embedded development nuances that were not initially apparent.

Unraveling Linker errors

Rust brings many advantages, one of which is freedom from dealing with traditional C/C++ linker errors. However, linking Rust and C in an embedded environment has presented a unique set of challenges. A particularly vexing issue arose when encountering a linker error that looked like this:

How did I encounter this problem?

While building Eerie, a Rust binding for IREE, I encountered a seemingly precarious aspect of a C API:

// Creates a new session forced to use the given |device|.
// This bypasses any device enumeration performed by the loaded modules but
// the loaded modules will still verify that the device matches their
// requirements.
//
// A base set of modules may be added by the runtime during creation based on
// |options| and users may load additional modules - such as the one containing
// their user code - by using the iree_vm_context_t provided by
// iree_runtime_session_context.
//
// |host_allocator| will be used to allocate the session and any associated
// resources. |out_session| must be released by the caller.
IREE_API_EXPORT iree_status_t iree_runtime_session_create_with_device(
    iree_runtime_instance_t* instance,
    const iree_runtime_session_options_t* options, iree_hal_device_t* device,
    iree_allocator_t host_allocator, iree_runtime_session_t** out_session);

Pass the memory allocator? Sure, we could just use:

What is Eerie?

Eerie is a Rust binding for IREE, an end-to-end compiler and runtime based on MLIR (Multi-Level Intermediate Representation). It serves as a transformative bridge for Machine Learning (ML) models, converting them into a unified Intermediate Representation (IR). For those unfamiliar with the ML compiler space, this process involves exporting models from frontend frameworks such as PyTorch, TensorFlow, and JAX into MLIR as a series of tensor operations. Subsequently, these models are compiled into IREE’s own IR. The runtime executes the model by interpreting the IR. For more information, you can refer to the IREE Website. In essence, Eerie provides a fully modular, ahead-of-time (AOT) compiled, lightweight ML engine!/ IREE can be seen as the LLVM of ML compilers. It supports many different backends including:

For passionate side project enthusiasts, documenting and sharing your projects can be a challenging task. Often, projects become a tangled mess with undocumented code, forgotten execution procedures, and hidden gems of experience buried in a labyrinthine GitHub repository. This isn’t an ideal scenario for showcasing your hard work and lessons learned.

Why Choose a Custom Blog Setup?

While there are popular blogging platforms like Medium, Blogger, or Wordpress, opting for a custom setup provides total control and a valuable learning experience. In this quest, I turned to Hugo, an incredibly fast static site generator implemented in GoLang. Hugo uses the versatile and dynamic syntax of html/template and text/template libraries.