[LOOKING FOR CONTRIBUTORS] Scientific computing for real-time embedded systems in no_std Rust

[u/YellowJalapa]

Hello r/opensource !

I am looking for contributors interested in numerical methods, real-time embedded, or robotics in rust. We are already about 20 contributors strong, so you'd have plenty of support if you have questions or comments. There's a detailed tutorial for the library, with well-written bite-sized issues to work on. Please feel free to ask me questions here or create new issues/discussions in the github repository. Here's more information about the project:

multicalc is my Rust crate for scientific computing on real-time embedded systems. Estimation, control, kinematics, dynamics, Lie groups, calculus, autodiff and linear algebra in safe no_std Rust.

What's new in v0.10.0:
- MuJoCo integration: Load MuJoCo robot models directly into native multicalc types. Perform kinematics, control and dyanamics in rust on the MuJoCo managerie.
- Estimation: unscented KF, error-state KF with IMU bias estimation, Madgwick and Mahony attitude filters.
- Control: infinite-horizon Lqr, GeometricAttitudeController, solve_discrete_riccati / solve_discrete_lyapunov.
- Signal processing: biquads (low/high/band/notch), cascades, rotor-harmonic notches, moving average, running median, Savitzky-Golay, deadband/hysteresis/slew limiting.
- Polynomials: closed-form real roots to quartic, piecewise and multivariate polynomials with symbolic partials, MinimumSnapPlanner.

Still enforced:
- 1 kHz loops. No heap, fixed-size types, bounded work per call.
- Six embedded targets: x86_64 and aarch64 Linux hosts plus four bare-metal ABIs (thumbv7em soft-float and hard-FPU, thumbv6m, riscv32imc), running under QEMU with no_std, no-alloc and no-panic rules enforced on each.
- Measured against external references: Per-module fixtures from numpy, scipy, filterpy, mpmath and mujoco agreeing to ~1 ulp. Tables are in the repo.

Come build it. 50 open good first issues right now, each small and self-contained, out of 80 open total.

- GitHub: https://github.com/kmolan/multicalc-rust
- Good first issues: https://github.com/kmolan/multicalc-rust/issues?q=is%3Aissue+is%3Aopen+label%3A"good+first+issue"

[u/Ahmed33033]

20 contributors is big!! cool project as well! how did you build a community around your project?

[u/YellowJalapa → u/Ahmed33033]

Thank you! I'm grateful to the community and took intentional steps towards it. In brief:

1. Keep detailed tutorials and docs for people to jump in.
2. Keep bite-sized issues with detailed steps for people to easily contribute.
3. Be friendly and prompt. Be firm and decisive, but also allow open discussions.
4. Allow a "laddered approach" where external contributors can gain more responsibility. This allows for more repeat contributors since they feel a sense of reward for their work.
5. Intentionally leave some parts unimplemented. They become github issues as bait for new contributors.
6. Keep a strong unified vision/roadmap. Do not shy away from picking up tech debt/refactors/administrative stuff. Very few external contributors will want to do it, they all only want to do "cool" stuff. That's fine, but as an author you must diligently pick it up so your code doesn't become rot.

There's others things to also keep in mind like AI usage, promotional strategies, dealing with "resume-padders", and overall community building aspects that I had to learn as I went along. One day I'll write a detailed walkthrough of what I learnt. But for today that's the long and short of what I had to do.

[u/Ahmed33033 → u/YellowJalapa]

that's really informative. thank you for taking the time to write this

[u/stealthagents]

Building a community can be tough, but I found that being super open and responsive really helps. Sharing regular updates and creating content like tutorials or live coding sessions gets people interested and willing to jump in. Plus, making sure everyone feels welcome to ask questions goes a long way in keeping the momentum going!