DataRail Violin Cortex Console is a touchscreen console built around one rig:
an NS Design WAV-4 electric violin playing into a Neural DSP Nano Cortex. The Cortex stays the
tone engine. The console sits beside it. It's built to record every take twice, dry and processed, to loop
against a sample-accurate bar clock, to read the dry signal to tune and review your playing,
to teach the positions, the scales that live in them and a tune, scoring every note as you
play it, and — new in 0.4.0 — to colour the loop you have built while what you play over it
stays exactly as the Cortex made it. Below it runs on a Lenovo Legion Go 2.
Two views. The video is a walk through version 0.2.0 on the Legion Go 2 with the violin
plugged in — the rig, then each screen; pick a chapter to jump straight to it. The still is
the Lessons tab that version 0.3.0 adds.
Filmed on a phone in September 2026: version 0.2.0 on a Legion Go 2, with the
Nano Cortex connected over WASAPI. It starts muted; turn the sound on in the player to
hear the violin.
Ten lessonsOpen strings, G, D and A major in first position, second, third and fourth position
on the A string, a first-to-third shift, holds against a drone, and Happy Birthday.
The notes come to youEach one falls down the lane of the string it is written for, in that string's
colour, labelled with the note name and the finger that stops it.
Forgiving or StrictForgiving stops the clock at a note you haven't played and waits for it, then gives
it its full length again and moves the rest of the lesson back with it. Strict lets the
note go by.
Scored on what can be heardThe pitch, how steadily you hold it, how cleanly it starts, and whether you hold it
for its written length. The string and finger are instructions: the pickup is one mono
signal, so nothing can check which you used.
Signal path
The Cortex makes the sound. The console listens.
Your live sound never passes through the console. It takes two copies of every note
from the Cortex over USB: the untouched pickup signal and the finished tone.
WAV-4NS Design electric violin, ¼″ jack out
Nano CortexCaptures, IRs and effects; monitors in hardware
USB-C48 kHz / 24-bit: dry DI plus processed stereo
Legion Go 2Runs the console: records, loops, reads and scores pitch
MonitorsFrom the Cortex's own outputs
Why no software monitoring? The Cortex already sends its tone straight to your
speakers or headphones. Routing that sound through the computer as well would add delay and
a second copy of every note. So the console records, loops and analyses, and leaves live
monitoring to the Cortex.
What it does
Five screens, one violin
Performance
The screen you play from. Large touch targets for record and the looper, the tempo, input
levels, and the Strings panel, which lights up with whatever you're playing.
Dual-path takes
Every take is recorded twice from the same instant: the dry pickup signal and the
Cortex's processed stereo, saved as a linked pair. The dry copy can be put through a
different tone later. Windows splits the Cortex into two stereo devices; the console
opens both and joins them, so all four channels arrive together.
Looper
One processed-stereo track, free-running or locked to 4/4 bars. Record, overdub, and one
step of undo and redo. Actions wait for the bar line, so loops close exactly in time.
Practice
A tuner that reads the dry signal, so effects never throw it off. After each take you
get a short review: range, intonation, sustain, timing and levels.
Lessons
Ten of them, from open strings to fourth position, a first-to-third shift, and Happy
Birthday. The notes fall down the lane of the string they are written for and are scored
as you play them: the pitch, how steadily you hold it, how cleanly it starts, and whether
you hold it for its written length. Forgiving mode waits at the line for a note you
haven't played yet; Strict lets it go by.
Effects on the loop New in 0.4.0
The Cortex makes your tone and keeps it — there is no amp, no cabinet and no drive here.
What the Cortex never sees is the loop, which leaves the console for its outputs without
passing through its processing. So that is what these touch: EQ and compression to hold a
stack of overdubs together, a delay written in note values that stays locked to the
looper's own clock, reverb to put the bed behind you, a ducker that dips it under
whatever you are playing, and width to leave the middle free. Applied on the way out, so
nothing recorded is changed and a reverb can be swapped while the loop it colours plays.
The animation
The four strings are the circuit
The circuit lines you can see down the edges of this page are the datarail.org circuit field.
In the console they become the violin's four strings. Here they're recoloured to match.
The A string lit, stopped in tune, with the vibrating length blurred from finger to bridge
and an attack pulse running out into the circuit.
G · magenta
D · violet
A · cyan
E · yellow-green
Idle, it runs like the website: trains of light along the traces.
The string you're playing lights up. The pickup can't tell strings apart, so the console makes a first-position guess from the note.
A marker sits where your finger stops the string: green in tune, blue flat, amber sharp.
The vibrating length blurs from finger to bridge, the way a real string does.
Each bow attack sends a pulse past the bridge, where the pickup sits, into the circuit.
Junctions flash on the beat when the metronome is running.
Specs
Version 0.4.0 in numbers
Audio
Format
48 kHz, 24-bit WAV
Inputs
Dry DI, mono, on input 1; processed stereo on inputs 3 and 4
Takes
Both paths from one audio callback, sample-aligned, saved as a linked pair
Monitoring
None in software; you hear the Cortex directly
Driver
WASAPI, joining the Cortex's two stereo devices into one four-channel stream; an ASIO build is still to come
Looper
Tracks
One, processed stereo
Timing
Free, or quantised to 4/4 bars
Tempo
40–240 BPM, with tap tempo
Clock
Sample-accurate bar lines
Layers
Overdub, with one step of undo and redo
Length
Up to 120 seconds by default
Practice
Pitch
YIN detection, 120 Hz – 3 kHz, on the dry DI
Tuner
±10 cents in-tune window, shown only when the reading is confident
Reference
Adjustable concert pitch, A4 = 440 Hz by default
Calibration
Open strings G3, D4, A4 and E5
After a take
Range, intonation in cents, sustain stability, timing against the metronome, peak and RMS, clipping. Tone is left to your ears.
Build
Engine
Native Rust, with a lock-free real-time audio path
App
Tauri 2, with a React and TypeScript interface
Platform
Windows 10 (1809+) and 11, x64; installs per user, no admin rights
Control
Touchscreen, keyboard, Novation Launchpad X
Sessions
Plain folders of WAV pairs and a session file, autosaved and indexed in a library
Look
Dark, light or follow Windows; animation Full, Subtle or Off
Tests
500+ automated tests across the engine and interface
Lessons
Lessons
Ten: open strings, G, D and A major in first position, second, third and fourth position on the A string, a first-to-third shift, intonation holds, and Happy Birthday
Notes
Written on a beat grid and played at 40–240 BPM, falling down the lane of the string they belong to
Scored
Pitch in cents, steadiness of pitch and level, how quickly the note arrived and settled, and whether it was held for its written length
Modes
Forgiving, which stops the clock at a note and waits for it, or Strict, which never waits
Drone
A sine at the note being asked for, through the Cortex's outputs, for the hold lesson
Not scored
Which string or finger you used. The pickup is one mono signal, so those are instructions rather than checks
Loop effects
Chain
EQ, compressor, delay, reverb, ducker, width, in that order, on the loop bed only
Delay
Written in note values against the looper's clock, so repeats stay on the grid when the tempo changes
Ducker
Keyed from the live signal: the bed dips while you play and comes back when you stop
Recorded
Nothing. The chain runs on the way out, so takes and the loop keep the sound that arrived
Never coloured
The metronome, the lesson drone, and what you are playing live
Control
Sliders on the Looper, named steps on the Performance screen, and one Launchpad pad per effect
Status
Where it stands
The video comes from the console's first sessions on real hardware. Here is what they
proved, what has been fixed since, and what comes next.
Working on the Legion Go 2
Installs from a single setup file, per user.
Finds the Nano Cortex over WASAPI and streams from it at 48 kHz.
Live pitch from the violin drives the Strings panel, the edge rails and the tuner.
Touch navigation across Performance, Sessions, Looper, Practice and Lessons, in dark or light.
Since 0.2.1: the window fits the Go 2's screen at 200 % scaling, sessions can be
created on it, and the looper and metronome play through the Cortex's own outputs, so
the bar clock ticks.
Picking the Cortex opens both of its stereo devices at once and joins them, so a take
is a dry and a processed file again.
Next
Playing the lessons and the loop effects through with the violin. Both are tested
note by note against generated signals, but 0.4.0 has not been run on the Cortex yet.
Confirming the two joined stereo devices stay aligned across a long take on the hardware.
ASIO, which would present all four of the Cortex's channels as one device. It hasn't
been tested with the Cortex yet.
Reconnecting the last device and session at launch.
Then take playback, MIDI clock, re-amping dry takes, and more tunes.
Contact
Want to hear more?
The console is in private development. For questions, a closer look, or to talk about a
rig of your own, get in touch.
