FSVR, Formant Synthesizer Virtual Rack, is a software reconstruction of the Yamaha FS1R as a plugin and a console synth: its firmware logic rewritten in C++ from the decompiled ROM, four parts, 32 channels, the filter, both LFOs, pan, the three effect blocks, performances and Fseq playback. VST3, CLAP, AU and standalone, with the front panel as the GUI.
Download the latest build: https://github.com/musicastudio/FSVR/releases/latest (no installer, no dependencies).
Licensed GPL-3, see LICENSE and NOTICE.md.
Discord: https://discord.gg/6sXu3GmkNm
The tone generator, the filter, the CPU-side firmware logic and everything that feeds them now match rgwan's FS1R inside the measurement, file by file. The one thing left is the effects layer, VOP3-2: its 87 algorithms are still modelled from the Data List rather than measured. See FS1R vs FSVR.
FS1R Hardware Recording
fs1r_demo02_hardware.mp4
FSVR (v0.4.2)
fs1r_demo02_engine.mp4
FS1R Hardware Recording
fs1r_demo01_hardware.mp4
FSVR (v0.4.2)
fs1r_demo01_engine.mp4
In 2025 Zhiyuan Wan (rgwan) created the rgwan/fs1r_firmware_RE repository to study the hardware and software on the Yamaha FS1R synthesizer. That project extracted the SH7044's 256 KB internal flash through a hooked UART, dumped the 2 MB external EPROM, dumped the PLG150-DX ROM, captured the board's UART traffic, and published a Ghidra project with the boot, loader, flash and LCD code already named.
The progress of this work was shared on the yamahamusicians.com forum.
Just over a year later in September 2026, James Hansen (jameshansen) created this repository, after analyzing and attempting to create the FS1R in software based on the material in rgwan's repository using a custom approach where the firmware files were decompiled with Ghidra into a database that can be read and explored by a coding AI agent.
Today, jameshansen and rgwan are collaborating on this project to improve the accuracy of the engine and bring it as close to the FS1R as possible.
AI coding agents and frontier LLMs have played a large role in making this project possible. The initial recreation was created using Claude Fable 5.1, which much of the ongoing analysis and engine improvements being assisted with Claude Opus 5. As part of the collaborative process, developers on the project can now use these tools via Discord.
Further hardware analysis is ongoing and planned. A patched firmware has been created to poke memory on a real FS1R to read registers and values, and taking die shots of the VOP3 is also being researched.
Where it stands, 2026-09-24: everything but the effects is done. Against rgwan's unit the synthesis engine matches close to 1:1. Every constant that models the two custom chips is measured off a recording or a register session rather than guessed, and every file in the 38-file capture set outside the three effect files sits inside the measurement: the amplitude EG, the formant window and its skirt on all seven forms, the noise formant, FM and feedback, detune, the velocity law, the per-voice filter and its EG, LFO1 and LFO2, pan and the output stage. The one remaining gap is VOP3-2, the effects DSP: reverb, variation, insertion and the master EQ are modelled from the Data List and read 17 to 29 dB against real impulse responses. Until that chip's program is decoded or its blocks measured against a register session, a performance with its effects on will differ from the unit in its reverb and effect tails and nothing else. docs/fidelity_plan.md has the numbers per file.
The FS1R (1998) is Yamaha's formant-shaping FM synth: 8 operators per voice, 32 channels, four parts, and a second oscillator type that generates a formant with a shaped spectral window instead of a sine. Its tone generator is the YMP706, a QFP128 part used in exactly two products, the FS1R and the PLG150-DX board. There is no public register documentation for it and no emulation of it anywhere.
FSVR is a rewrite of that logic, not an emulation of the processors on the board. The SH7044 is not emulated and its firmware does not run here. tools/build_fs1r_ghidra.py imports the EPROM into Ghidra as SH-2 and decompiles it, and the note-on path, the tick pipeline, the parameter conversion tables and the 88-algorithm routing table are read straight out of that code and ported to C++. The two custom chips cannot be treated that way, since nobody has register semantics for the YMP706 or an instruction set for the YSS236, so they are models, and every constant behind them sits in src/fs1r/chips/cal.h where calibrating against a recording of a real unit is one table edit.
Three words carry the status of each piece below. Read is lifted out of the decompiled firmware, its tables or the board, and needs no calibration. Measured is a model whose constants came off a recording of rgwan's unit rather than off a guess. Modelled is inferred from the DX7 lineage, Yamaha's formant synthesis patent (US5610354) or the Data List, and marked INFERRED in the source.
The practical result is that patches, performances and Fseqs load and play with the same parameter interpretation the hardware uses, because the same logic computes them. What still differs from a real unit lives inside the two custom chips.
A short list of places FSVR behaves differently on purpose is kept in docs/Differences.md, with the firmware address behind each one. There is one entry today: a part's filter switch is live here, so turning the filter on or off reaches the notes already sounding, where the unit latches that switch per note at note-on and only its cutoff and resonance follow a held note.
-
SH7044 CPU, SH-2 at 28 MHz with 256 KB of internal flash. Read, and verified against the unit. The firmware's logic is rewritten in C++: the note-on path, the 192.3 Hz MTU2 tick, the CMT1 Fseq frame timer and every conversion table. rgwan ran a debug monitor over the whole capture set on 2026-09-18 and read the voice image back segment by segment, so the CPU side is checked byte for byte, 240,476 checks over 802 segments with no mismatch. Running the real firmware on an emulated SH-2 core (gearmulator has one with the SH7040 peripherals) stays on the list as a second opinion, not as a replacement.
-
YMP706-F tone generators, two of them, 16 channels each on an 8-bit write-only bus. CPU side read, chip side modelled and largely measured. There is no register documentation and no die shot, and the chip is too rare for one, so it stays a model. Everything the CPU computes for it is read from the firmware: all 88 algorithms, the DX7 VCED and ACED conversion, frequency words, EG rate and level conversion, velocity curves and attenuation, level key scaling, EG bias, note shifts, part detune, master tune, bend, the software pitch EG, LFO1 and LFO2, portamento, the mono modes with priorities and legato, note and velocity limits, part volume, expression and balance, and pan. What the chip does with those values breaks down as follows.
- The amplitude EG. Measured. The rate law holds to 0.6 % over 38 measured rates and the level register is 0.376287 dB a step, a halving every sixteen. The attack's shape, its floor, the hold's length and the key rate scaling were all DX7 guesses and all wrong until two envelope recordings settled them; shape error over a hundred segments went from 5.45 dB rms to 0.58. The key code law is a table measured at every one of its 37 key codes, and the hold does not scale with it. docs/aeg.md.
- FM, feedback and the modulation index. Measured. 3.369 cycles at full level, off two sideband sweeps and confirmed by
03_fm's own spectra; feedback is0.5 * 2^(fb - 7). - Detune. Read, and it needs no constant at all. It is not a fixed step but the EPROM's own key scaled
FRMDETtable, matched over six octaves to half a cent, which took a vibrato off demo song 2 that the unit does not have. docs/detune.md. - The voiced formant window. Measured. The window is a time set by the bandwidth byte, the skirt doubles a
sin^pexponent per step, and there are two window shapes: symmetric onall2,odd2andres2, asin^prise on asin^2fall onall1,odd1,res1and the formant.all1andall2are that window alone, read by phase. All six harmonic forms land inside 0.5 to 1.8 dB of the unit's line amplitudes at every skirt, and the formant's skirt sweep at 0.44 dB of band shape. docs/skirt.md, docs/formant.md. - The noise formant, the unvoiced operator. Measured, 2026-09-21 and 2026-09-22. Two digital one-poles with different coefficients on white noise, both read off the register and the skirt at three centres, a two-sample mean on the output, a level table and a threshold resonance. Level error over the four unvoiced files is 0.2 to 1.05 dB and the octave bands agree inside 0.5 dB to 16 kHz. The resonance carrier's amplitude and the noise it cuts are read against the register at four settings (2026-09-24). docs/noise.md.
- Amplitude modulation sensitivity. Measured: the chip's AM word is seven bits and the sensitivity is a 3-bit shift-and-add, {0,1,2,4,5,6,7,8}/8.
- Which write starts a note. Unknown. 0xFC/0xFD goes out before the registers load and nothing says what the chip makes of it.
-
YSS236-F / VOP3-1, the per-voice filter, at 0x800200. CPU side read, response measured. Yamaha's VOP3 is the same programmable DSP that is the synthesis engine of the AN1x, AN200 and PLG150-AN; the FS1R has two, and this one sits in a channel-level loop off both tone generators. The CPU's whole side of it is read out of the firmware: sixteen filter channels mapped to parts, a dirty flag per parameter group, and closed-form conversions for cutoff, resonance, type and input gain. The response is measured off
15_filter: the corner is17.4 * 2^(byte / 12)to 0.098 octaves rms, the three lowpasses are taps off one 4-pole ladder whose feedback goes as the cube of resonance table A, and HPF, BPF and BEF a 2-pole state-variable filter, 24, 18, 12 and 12 dB per octave to a decibel. The filter EG is stepped segment by segment by the CPU and run by the chip; its rate law came off the CPU's own stage word over the debug monitor and its depth scale off one recording.tools/extract_vop3.pyhas the microcode out intodocs/vop3/, register by register, but the instruction set is undecoded. -
YSS236-F / VOP3-2, the effects, at 0x800000. Parameter encoding read, algorithms modelled. The one remaining gap in the engine. Reverb (17 types), variation (29), insertion (41) and the master EQ in the XG topology, with the part dry and send levels and the insertion switch, in
src/fs1r/chips/vop3_effects.h. The parameter encoding is read rather than guessed, recovered out of the 360 preset performances and matching every documented default. The 87 algorithms themselves are modelled from the Data List, and were measured against real impulse responses for the first time on 2026-09-21, at 16.9, 27.2 and 28.8 dB over eighty-four segments, in a set where most files agree with the unit inside half a decibel.tools/extract_vop3_2.pyhas that chip's two images out intodocs/vop3_2/. Decoding the VOP3 instruction set is the only route to bit-exact effects and a bit-exact filter; it is open research on the scale of a full DSP core, and the modelled effects ship regardless. -
The board around them. Read. One 24.576 MHz crystal runs the audio side and the main Sanyo LC78834M DAC is the I2S master at exactly 48 kHz, so the engine runs at 48 kHz whatever the host rate and resamples on the way out. The recording tap is that DAC's I2S input, after both DSPs and before the analogue volume pot, which is what makes a recording's absolute level comparable. The output path's fixed gain, the hard clip on the channel accumulator and the filter loop's insertion loss are all numbers off that tap.
docs/research.md2.0.1 and section 8 have the clocking and the CS2 decode.
All read from the firmware and its tables, and all finished.
- Factory data. The 1408 preset voices, 384 performances and 90 formant sequences out of the EPROM, plus the voice (608 bytes), performance (400), Fseq and system bulk layouts and the DX7 VCED and ACED maps. Extracted into
presets/and built into the plugin, so the patch browser needs no EPROM image. TheInternal Perform BankandInternal Voice Bankis actually cherry-picking frompreset performancesandpreset voicesby factory set routines to NVRAM in real unit, we decided not to implement it in FSVR, because you can always find these performances and voices from preset voices, and your voice can be store in SysEx, therefore makes it not necessary as a plugin. - Fseq playback. Frame timing on its own timer, every loop mode with the direction the loop points imply, the start offset, the performance start delay, scratch mode from controller destination 47, MIDI clock sync at all five speed ratios, and the voice Fseq switches.
- Controller sets. The whole matrix out of three firmware functions: the source bit order, the bipolar and raw source conversions, the clamped sum, the three scalers and which of the 48 destinations uses each, the per-part gate, and the destinations that edit a part byte instead of contributing an offset. The voice's own Formant and FM control matrix with it.
- MIDI and sysex. The whole parameter map in both directions, bulk dumps and parameter changes in and out, dump and parameter requests answered with checksummed replies, RPN 0-2, the ten NRPN 01 xx part parameters, bank select and program change in both performance and multi modes, MIDI clock and active sensing.
- The panel. The plugin's GUI is the front panel, and the cursor stops and controller set behind it are read out of the EPROM's own screen tables rather than off a photo.
docs/interface_from_firmware.md.
Against rgwan's digital recording of the built-in demo, which the unit plays from its own EPROM so the same byte stream drives both, with the effects in the path on both sides: median envelope correlation 0.976, worst 0.912, mean band error 5.0 dB and tilt 2.0 dB. Against the 38 frozen capture files, twenty-seven agree with the unit inside half a decibel of level; the velocity law, the EG decay to a level, the modulator chain and the second and third links of it are inside a tenth, and the eleven that do not are the three effect files, two whose number is a scoring artifact below 100 Hz, two at frame and LFO rates the analyzer cannot align, two at 1.2 and 1.7 dB, and the two session-4 files whose level column measures a decay window and an 8 kHz noise offset rather than a level.
Nothing in cal.h is a guess any more, and nothing outside the effects is open. The last three modelling items closed on 2026-09-24 off data already recorded: the window family behind the "1" forms and the formant, the all1/all2 construction, and the key code table at the demo drum's note; the fourth hardware session the same day then read that table at every semitone, found the EG hold does not scale with it, and read the unvoiced resonance carrier against the bandwidth register. docs/fidelity_plan.md has the per-file table; STATUS.md carries the KNOWN / INFERRED / UNKNOWN lists and the open work; FS1R.unlock/captures/fs1r_capture_session4.py holds the one register dump still to run, the per-channel arrays, which the engine is not waiting on.
Known issue: performances that layer two parts of a voice with all eight unvoiced operators live (A020 Vox Morph is the extreme) are heavy, about half a desktop core at 8 notes and more than a laptop i7 has to give. docs/performance.md has the measurements and the fixes in order of cost.
What is left is the effects layer, VOP3-2: 87 algorithms modelled from the Data List, 17 to 29 dB against real impulse responses over eighty-four segments. It is a rebuild of each block from the microcode or a measurement of each against a register session, and it is the last piece. Tiers 0 to 3 and 5 are done, so the engine, the library and console split, the plugin in all three formats, the front panel GUI, the licence and CI are all in, and Tier 4, fidelity and verification, is complete outside the effects.
The latest release has zipped VST3, CLAP and standalone builds for Windows, Linux and macOS, with an AU for Logic Pro in the macOS zip. The macOS builds are universal, Apple silicon and Intel in one binary. No installer, no dependencies.
Every push to main builds the same set through GitHub Actions, so a build for an OS you do not own is always one Actions run away, including on a fork. .github/workflows/build.yml is three jobs:
- engine, on
windows-latest,ubuntu-latestandmacos-latest. Plain CMake with no submodules, thenctest, which runs the effect self check everywhere and the engine self check on Windows. UploadsFSVR-console-windows. - plugin, on the same three. Checks out the submodules, installs the X11, ALSA and FreeType packages JUCE asks for on Linux, configures with
-DFS1R_BUILD_PLUGIN=ON, and uploadsFSVR-plugin-windows,FSVR-plugin-linuxandFSVR-plugin-macos, each holding the VST3, the CLAP and the standalone for that OS, and the AU as well on macOS. - release, on a
v*tag only. Zips every artifact and attaches it to a GitHub release.
CMake everywhere, C++17. The engine, the console and the self checks need no submodules and no dependencies:
cmake -B build/cmake -S . # fs1rLib, test_effects, bin/render_capture, and bin/fs1r_emu on Windows
cmake --build build/cmake --config Release
ctest --test-dir build/cmake -C Release # the self checksSource obtained any way other than git clone — a chat upload, a support agent's export, a manual copy of
individual folders — is not guaranteed to carry every file under tools/. A CMake configure error naming
tools/test_effects.cpp or tools/render_capture.cpp as missing means the source tree is incomplete, not
that those targets are optional: test_effects is the effect self check that build.bat test and CI both
run, so dropping it from CMakeLists.txt to get a configure to pass silently disables that check instead
of fixing anything. Re-clone from GitHub rather than editing the targets out.
The plugin needs the submodules and adds one flag:
git submodule update --init --recursive
cmake -B build/plugin -S . -DFS1R_BUILD_PLUGIN=ON
cmake --build build/plugin --config ReleaseVST3, CLAP and a standalone land in bin/VST3, bin/CLAP and bin/Standalone, plus an AU in bin/AU on macOS, which is the only plugin format Logic Pro loads. The 1408 factory voices, the 384 factory performances and the 90 preset formant sequences are built into the plugin, so its patch browser needs no EPROM image. docs/plugin_guide.md is the user guide.
On Windows build.bat is the shortcut, MSVC x64 out of the VS 2022 Professional vcvars64:
build.bat bin\fs1r_emu.exe, the console
build.bat test build and run the self checks
build.bat plugin the two plugin CMake commands aboveEverything meant to be run lands in bin/; objects and the test binaries go to build/.
bin/fs1r_emu is the test harness on top of the engine library. It is Windows only, since it uses WinMM for MIDI and waveOut for audio, but its offline render path needs no devices at all.
fs1r_emu -l list MIDI ports
fs1r_emu asks for a MIDI input once, remembers it in bin\fs1r_emu.ini
fs1r_emu -m 0 -o 0 -v presets\native\000_Ballad_EP.syx
fs1r_emu -v presets\dx7\004_Pianotone1.syx DX7-format presets, converted the way the firmware does
fs1r_emu -r <eprom.bin> -p 128 ROM voice, 0-255 native and 256-1407 the DX7 banks
fs1r_emu -r <eprom.bin> -P 0 ROM performance 0-383 with its voices and Fseq
fs1r_emu -r <eprom.bin> -P 0 -f 29 override the Fseq with preset Fseq 1-90
fs1r_emu -v presets\native\128_BagPipe.syx -w test.wav -n 60 -d 3 offline render, no devices neededOptions. -m MIDI input, -o MIDI output for dump and parameter replies, -c force all parts onto one MIDI channel (the default is each part on its own receive channel), -v a sysex file holding FS1R voice, performance or Fseq bulk dumps or a DX7 VCED dump, with -p picking the n-th dump in the file, -r a 2 MB EPROM image with -p voice, -P performance and -f Fseq, -g output gain, -w offline render with -n note, -n2 a second note a third of the way in, -cc num=val control changes sent before the note, -d seconds, -mono part 1 mono with full-time portamento, -selftest the engine self check. FS1R_DEBUG=1 prints the computed register values at every note on.
MIDI. Notes, bend, both aftertouches, the control numbers the system table assigns to KN1-4, MC1-4, FC, BC, Formant and FM, CC5/65 portamento, CC7 volume, CC10 pan, CC11 expression, CC64 sustain, CC91/94 sends, CC120/121/123/126/127, RPN 0-2, the ten NRPN 01 xx part parameters, bank select and program change in both performance and multi modes, MIDI clock, active sensing, FS1R bulk dumps and parameter changes across the whole map, and dump and parameter requests answered. The performance's controller sets route the sources to the destinations.
The EPROM image the -r examples take is rgwan's dump with its 16-bit words byte-swapped into CPU order, kept outside this repo in ../FS1R_DISASM/roms/. FSVR does not ship it, and nothing but the -r paths needs it.
python tools/check_wav.py test.wav 60 # pitch, harmonics and envelope of one render
python tools/regress.py # the whole fixed preset list against the stored referenceEngine. No Windows, no host, no GUI. This is what the plugin links. The tree says where a claim comes from, which is the thing to know before changing anything in it.
src/fs1r.hthe public header,fs1r::Device. The only one the plugin includessrc/fs1r/hardware.hthe FS1R's own numbers, read off the board. Facts, never tunedsrc/fs1r/internal.hthe engine's shared declarations, includingstruct Synth
src/fs1r/firmware/ is KNOWN, rewritten from the disassembly, and every claim in it cites a FUN_ address. A disagreement with a real unit is a bug here, not a calibration.
patch.cppvoice, performance and part data as the firmware decodes it, with the DX7 conversioncontrollers.cppthe eight controller sets, the three scalers and the 48 destinationsnotes.cppnote on and off, operator setup, pitch, portamento, and the 192.3 Hz tickfseq.cppformant sequence playback;midi.cppMIDI in and sysex in and out;rom.cppEPROM and sysex loadingtables.hthe EPROM's conversion tables, bytools/extract_tables.py;algorithms.hthe 88-algorithm routing table
src/fs1r/chips/ is INFERRED, because neither custom chip has public register documentation. These are claims about the hardware, changed by measuring against a recording and never by taste.
cal.hthe calibration surface, every modelled constant in one placeymp706.cppthe tone generator: operators, envelopes, the formant window, and the render pathvop3_filter.hVOP3-1's filter;vop3_effects.hVOP3-2's reverb, variation, insertion and master EQ
src/fsvr/ is ours. Nothing in the hardware corresponds to any of it.
tuning.hcost knobs, the control-rate decimation and the queue cap. Changing one must not change the outputdevice.cppfs1r::Device, host-rate resampling and state as bulk dumpssmf.hStandard MIDI File reading;selftest.cppthe engine self checksrc/console/main.cppthe test console: WinMM MIDI in and out, waveOut, offline render
Plugin. The JUCE layer, which never models synthesis; it moves parameter values in and out of the engine as sysex, exactly as a hardware editor would.
plugin/PluginProcessor,PluginEditor,PanelView,EditorPages,PatchManagerandParameterDescriptionsplugin/fs1r_panel.svgthe front panel artwork, generated bytools/make_panel_svg.pyplugin/fs1r_presets.syxwith its indexfs1r_presets.csv,fs1r_performances.syxandfs1r_fseqs.syx, the bundled factory banks, packed frompresets/bytools/make_presets_blob.pyplugin/parameterDescriptions_fs1r.jsonthe 893 parameters with their sysex addresses and bit layouts, generated bytools/gen_parameters.pyextern/JUCE and clap-juce-extensions, as submodules
Tools, firmware.
tools/build_fs1r_ghidra.pyimports and decompiles the firmware into../FS1R_DISASMwith pyghidra (SH-2);decomp.py,ghidra_disasm.py,ghidra_switches.py,ghidra_handlers.pyandghidra_probe.pyquery ittools/ghidra_ctrl_dests.pydecompiles the 48 controller destination handlers, which Ghidra never turns into functions because only a pointer table reaches themtools/extract_tables.py,extract_presets.pyandextract_demo.pypull the conversion tables, the 1408 voices, 384 performances and 90 Fseqs, and the demo songs out of the EPROM imagetools/extract_vop3.pyandextract_vop3_2.pypull the two VOP3 microcode uploads intodocs/vop3/anddocs/vop3_2/
Tools, calibration.
tools/make_capture_set.pywritescaptures/requests/, the hardware capture kit: Standard MIDI Files that play a measurement into a real FS1R, each setting up its own patches by sysex and opening and closing with a marker so a recording aligns itself. Built out oftools/fs1r_patch.py; the othermake_capture_*.pyare the later additions to the settools/analyze_capture.pyaligns a recording to the manifest, measures every segment, fits the constants it can, and diffs the result against our own render of the same file.bin/render_capturemakes that render, which is also how a request file is checked before anyone is asked to play it.tools/bench_captures.pyrebuilds the renderer from the source as it stands and prints one line per file;tools/render_demo.shdoes the same for the demo set and appends to the ledgertools/render_song.py,check_demo.pyanddemo_probe.pyplay the extracted demo songs through the engine and score them against rgwan's recording;demo_scores.txtis the running ledgertools/pitch_track.py,split_capture.pyandanalyze_unvoiced2.pythe per-measurement readers
Tools, checks.
tools/regress.pyrenders the fixed preset list and diffs it againstregress_ref.json: pitch, harmonic peaks, envelope, stereo width, centroidtools/test_effects.cppdecodes and sweeps every effect type, andfs1r_emu -selftestis the engine check. Both run underctesttools/check_wav.py,check_formant.py,check_presets.py,check_panel.pyandcheck_interface.py, the rest of whatbuild.bat testruns;check_skirt.pyrenders every harmonic form at every skirt against the register sweep
Data.
presets/the factory voices, performances and Fseqs as.syxwithindex.csv, plus the DX7 bankcaptures/requests/the capture kit as MIDI with a README listing what each file settles,captures/hardware/the recordings that came back,captures/analysis/the per-segment numbers,captures/engine/our own renders of the same files
Docs.
- docs/research.md what is known about the hardware, and docs/ymp706_registers.md the tone generator interface and the CPU-side engine lifted from the firmware. These two are the reference.
- docs/fidelity_plan.md the ranked read of where the engine stands against every recording;
capture_0918.mdandhardware_capture_request.mdare the capture working docs/aeg.md,formant.md,skirt.md,noise.mdanddetune.md, one measurement each, the working behind the constants incaldocs/midi_dispatch.mdhow a Note On, a Control Change and both aftertouches get from the SCI0 interrupt to the tone generator;interface_from_firmware.mdthe panel's cursor stops and controller set, read out of the EPROM's own screen tablesdocs/vop3_microcode.md,vop3_2_microcode.mdandvop3_pinout.mdthe VOP3 reference- docs/Differences.md the short list of places FSVR knowingly behaves differently from the unit, and why
- docs/plugin_guide.md the plugin user guide. The Data List and owner's manual text and the formant patent are here too.
- STATUS.md what is known, what is modelled and what nobody knows, with the open work at the end
- docs/findings.md the research log, newest first, and the evidence behind each constant
