01 / researchExtract a structured paper record
A staged processing job separates metadata, architectures, metrics, datasets, and implementation details.
FastAPI · Gemini integration · SQLModelNeuromosaic00
Neuromosaic
Make the space between ideas inspectable.
Original identity / a family of related forms
The original website identity gives related structures distinct contours, held together as one family of forms.
A neural architecture is more than a model name. It is a set of components, parameters, implementation choices, and experimental conditions. I built Neuromosaic to connect those layers: begin with research, describe an architecture, generate code, and keep the resulting experiment attached to what produced it.
RoleResearch + engineering
AudienceML researchers + builders
CorePython + PyTorch
SurfacesExplorer + CLIresearch prototype; incomplete search strategies
01
The consequential problem
A paper is not yet an experiment
Research knowledge loses its structure on the way into code.
A paper may describe an attention mechanism, a normalization choice, and a training setup in different sections. Reconstructing a useful experiment means keeping those relationships intact while making room for deliberate variation.
I wanted a workbench where the architecture, the generated implementation, and the recorded result could be inspected together. That required a common representation before adding a search algorithm or a richer visualization.
- Keep components and parameters explicit.
- Preserve a route back to the source research.
- Attach experiment results to the implementation that produced them.
02
What I saw
Give the idea a representation
An architecture becomes easier to vary when its choices have names and bounds.
The architecture space separates continuous parameters from categorical choices: layer count, hidden size, attention heads, feed-forward variants, normalization, and activation. An encoder turns that specification into a vector that can be decoded again.
That representation gives code generation and exploration something concrete to work with. The visual interfaces can then offer two different scales of inspection: a spatial model overview and a node-based architecture hierarchy.
03
The decision that changed the system
Keep the provenance attached
Treat generated code as one step in an experiment with a history.
The orchestration cycle requests an architecture, generates code, versions it, runs the configured execution environment, and records the architecture specification alongside metrics and the code version. Cleanup sits in a finalization path so a failed run still has an exit.
Paper ingestion follows a separate, staged job: download, extract metadata and architecture details, gather metrics and datasets, then persist the record. Its progress is exposed to the explorer instead of hiding the whole operation behind one spinner.
01Read
Bring a paper into a staged extraction workflow.
02Represent
Describe the components, categorical choices, and parameter ranges.
03Run
Generate and version the implementation before executing the configured experiment.
04Inspect
Return to the specification, code version, recorded metrics, and architecture view.
04
System anatomy / rationale / surfaces
Architecture / an experiment carries its context
The interfaces change. The experiment needs to stay identifiable.
A Python research core coordinates architecture encoding, code-generation providers, execution, and stored results. The Next.js explorer provides a separate route into papers and architecture structure.
Decision anatomy / select a knot
Pressure did not decorate the architecture. It determined it.
Before / tension
A model name hides the choices worth changing
The knot / decision
Encode bounded parameters and named component variants
After / consequence
Candidate architectures have an explicit specification before code generation begins.
02 / representationMake the search space explicit
Architecture vectors encode numerical bounds and categorical options rather than relying on a free-form model description.
Python · NumPy · architecture encoder03 / experimentBind implementation to results
The orchestration cycle retains the architecture specification, code version, execution status, and returned metrics together.
PyTorch · provider interfaces · version control04 / inspectionMove between overview and structure
The website includes selectable 3D model points and a pan-and-zoom hierarchy of architectural components.
React Three Fiber · Three.js · React FlowArchitecture rationale / pressure → choice → consequence
PressureDecisionWhy it mattered
A model name hides the choices worth changingEncode bounded parameters and named component variants
Candidate architectures have an explicit specification before code generation begins.
A generated file can become detached from its resultRecord code version, architecture, and metrics in one cycle
A result retains the context needed for later inspection and comparison.
An overview cannot explain a model's internal structurePair spatial model selection with a node-based hierarchy
Exploration and detailed inspection get different views of the research.
Surface atlas
The system becomes tangible through the places people encounter and use it.
Paper explorer
Search and inspect papers while processing jobs expose their current stage.
Architecture view
A React Flow hierarchy makes components and their relationships visible.
Model space
Selectable 3D points provide a spatial route into model details.
CLI
Quickstart, workflow, inspection, and analysis commands frame the research loop.
Research core
Python · PyTorch · NumPy · Pydantic
Services
FastAPI · SQLModel · PostgreSQL · Docker
Explorer
Next.js · React Three Fiber · React Flow · TypeScript
Technology atlas / select a tool
The tools behind the decisions.
Select a tool to see the role it plays in this system.
- Research / Neuromosaic
Python
One research core connects architecture specifications, code generation, experiment orchestration, and recorded results.
05
Authentic proof
Original visual study / components and relationships
Original website artwork: reflective components remain individually visible while forming a larger field.
06
What changed in my operating model
Make the result traceable
A useful research surface lets you follow the result back to its choices.
The most consequential design choice was keeping architecture, implementation, and experiment context connected. A spatial overview helps you find something worth inspecting. The component hierarchy and recorded code version help you understand what you found.
Neuromosaic remains an alpha research prototype: the explorer includes sample records, and parts of the search strategy are unfinished. A completed search loop and reproducible baseline are the next steps toward a defensible discovery claim.
- Preserve the specification alongside the implementation.
- Give overview and detailed inspection distinct jobs.
- Make the difference between sample data and experimental evidence explicit.