NoseKnows

• 

  Thin UX layer over Rust internals. Daft for dataset management and ledgering.

Inspiration

The inspiration for NoseKnows arose from the inefficiency of centralized AI. We currently treat every sensory input as a cloud-bound data packet, ignoring the elegance of biological systems. Nature doesn't send "smell data" to a central processor; it performs local, analog feature extraction in the olfactory bulb. I wanted to replicate this by creating a synthetic "olfactory nerve" capable of generating high-dimensional chemical embeddings at the edge, using nothing more than mass-produced silicon and basic materials.

The Build

The system core is an 8-input sensor array using graphite pads deposited on alumina ceramic substrates. A combination of metal oxide liquids are used to dope the gaps, with each pad acts as a resistive sensor with varying sensitivity to volatile organic compounds.

1. Analog Front-End: The sensor array is biased with a simple voltage divider, where the resistance $R_s$ changes based on chemical adsorption.

2. Embedding Generation: Instead of simple thresholding, the system performs a non-linear mapping. The raw vector $\mathbf{v} \in \mathbb{R}^8$ is mapped to a latent space $\mathbf{E} \in \mathbb{R}^{1024}$ using a weight matrix $\mathbf{W}$ that encodes specific chemical signatures:

$$\mathbf{E} = f(\mathbf{W} \cdot \mathbf{v} + \mathbf{b})$$

1. Rust Firmware: The entire pipeline is implemented in no_std Rust on an ESP32. By leveraging Rust’s memory safety, I ensured the sensor polling and the matrix-vector multiplication operate within a strict 20ms window, minimizing jitter.

Challenges Faced

The primary challenge was thermal noise management. Graphite-on-ceramic is incredibly sensitive to ambient temperature fluctuations, which can mask the chemical signal. I mitigated this by implementing a differential measurement technique where one sensor is sealed, acting as a reference to subtract common-mode thermal noise:

$$V_{out} = V_{sensor} - V_{ref}$$

Another hurdle was the dimensionality mismatch. Projecting 8 raw inputs into a 1024-dimensional embedding space required extreme optimization to fit within the ESP32’s limited SRAM. I solved this by using fixed-point arithmetic instead of floating-point, ensuring the model weights were quantized and stored in flash memory rather than heap-allocated.

What I Learned

Hardware-software co-design isn't just a strategy...it’s the only way forward. You can't just throw a black-box model at a problem. You have to engineer the physical substrate, like these graphite pads, to work in concert with the mathematical transforms. Moving toward analog-style compute is about more than just saving power. It shifts how we define intelligence, and moving away from the rigid, centralized bottlenecks. Embrace the fluid, the reactive, and truly localized.

Built With

• codex
• esp32
• python
• rust