Quaternion Alternatives
Similar projects and alternatives to Quaternion
-
diffractsim
✨ A flexible diffraction simulator for exploring and visualizing physical optics.
-
haiku
The Haiku operating system. (Pull requests will be ignored; patches may be sent to https://review.haiku-os.org).
-
WorkOS
The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.
-
fdtd
A 3D electromagnetic FDTD simulator written in Python with optional GPU support
-
-
-
mini-cheetah-tmotor-python-can
Python Motor Driver for Mini-Cheetah based Actuators: T-Motor AK80-6/AK80-9 using SocketCAN Interface
-
SPSCQueue.h
A bounded single-producer single-consumer wait-free and lock-free queue written in C++11
-
InfluxDB
Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
-
-
WonderBrush-v2
Last known version of the code to WonderBrush (as included in Haiku)
-
-
Quaternion reviews and mentions
- Haiku R1/beta4 has been released
-
Notes on Concurrency Bugs
In terms of shared-memory threading concurrency, Send and Sync, and the distinction between &T and &Mutex and &mut T, were a revelation when I first learned them. It was a principled approach to shared-memory threading, with Send/Sync banning nearly all of the confusing and buggy entangled-state codebases I've seen and continue to see in C++ (much to my frustration and exasperation), and &Mutex providing a cleaner alternative design (there's an excellent article on its design at http://cliffle.com/blog/rust-mutexes/).
My favorite simple concurrent data structure is https://docs.rs/triple_buffer/latest/triple_buffer/struct.Tr.... It beautifully demonstrates how you can achieve principled shared mutability, by defining two "handle" types (living on different threads), each carrying thread-local state (not TLS) and a pointer to shared memory, and only allowing each handle to access shared memory in a particular way. This statically prevents one thread from calling a method intended to run on another thread, or accessing fields local to another thread (since the methods and fields now live on the other handle). It also demonstrates the complexity of reasoning about lock-free algorithms (https://github.com/HadrienG2/triple-buffer/issues/14).
I suppose &/&mut is also a safeguard against event-loop and reentrancy bugs (like https://github.com/quotient-im/Quaternion/issues/702). I don't think Rust solves the general problem of preventing deadlocks within and between processes (which often cross organizational boundaries between projects and distinct codebases, with no clear contract on allowed behavior and which party in a deadlock is at fault), and non-atomicity between processes on a single machine (see my PipeWire criticism at https://news.ycombinator.com/item?id=31519951). File saving is also difficult (https://danluu.com/file-consistency/), though I find that fsync-then-rename works well enough if you don't need to preserve metadata or write through file (not folder) symlinks.
Stats
quotient-im/Quaternion is an open source project licensed under GNU General Public License v3.0 only which is an OSI approved license.
The primary programming language of Quaternion is C++.