Instructions to use cowWhySo/Underdog-Woof-MLX with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- MLX
How to use cowWhySo/Underdog-Woof-MLX with MLX:
# Download the model from the Hub pip install huggingface_hub[hf_xet] hf download cowWhySo/Underdog-Woof-MLX --local-dir Underdog-Woof-MLX
- Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- LM Studio
- Atomic Chat
- Underdog Woof on Apple Silicon: bit-exact C speech step and MLX decoder
Underdog Woof on Apple Silicon: bit-exact C speech step and MLX decoder
Run Underdog Woof about 2.3-2.8x faster on a Mac, with a fix for a sentence-splitter bug that makes the model repeat words on some long sentences. On text that upstream splits cleanly, the default engine matches the reference engine to within one 16-bit audio step. With the NumPy decoder kept, the waveform is bit-identical to the reference.
This is a derived work of Underdog Woof by Conway, released under the Underdog Non-Commercial License 1.0
(see License below). The weights file and the whole underdog_woof/ package are byte-identical to
upstream revision be70296. What this repo adds:
woof_fast.candwoof_fast.py: a compiled per-frame speech step. It is bit-identical to the NumPy reference, so a seed gives the same latents and the same waveform. It needs the Xcode command line tools.mlx_decoder.py: the Mimi-derived audio decoder on the Apple GPU through MLX.mlx_woof.py: an experimental MLX speech stage. It is slower than the reference and is a documented negative result.- A Core ML experiment for the flow head, also a documented negative result.
woof_split.py: a fix for the splitter bug, on by default in every engine here. See Sentence-splitter fix.- Validation, benchmark and comparison scripts, and the evidence they produced on an M4 Max.
Quickstart (Apple Silicon Mac)
python3 -m venv .venv && source .venv/bin/activate
python -m pip install -r requirements-mlx.txt # numpy and mlx
bash build_ext.sh # compiles the C speech step (Xcode command line tools)
Run everything from the repo root, because underdog_woof/ and the scripts sit side by side.
Recommended: compiled speech step plus MLX decoder
from woof_fast import make_fast_woof
tts = make_fast_woof("woof_int8.npz", voice="juno") # or voice="mira"
wav = tts("Please call me back at 415-555-0199 before 5:30 p.m. on Friday.", seed=1)
tts.save("out.wav", wav) # 24 kHz mono PCM16
Same seed, same text normalization, same retry logic, same sampled latents as the reference. The one deliberate difference is the splitter fix, which changes how a long sentence is cut into pieces only where upstream would end a piece mid-phrase. Options:
make_fast_woof(..., fix_splitter=False)restores upstream's exact splitting. Use it to compare with the reference engine bit for bit on any text.make_fast_woof(..., mlx_decoder=False)keeps the NumPy decoder. With the splitter fix off, or on text the fix does not touch, the waveform is then bit-identical to the reference, sample for sample.make_fast_woof(..., threads=1)orWOOF_THREADS=1turns the thread pool off. The default is 2. The result never changes with the thread count, only the speed.
No compiler available: MLX decoder only
from mlx_decoder import make_mlx_decoder_woof
tts = make_mlx_decoder_woof("woof_int8.npz", voice="juno")
Reference engine (NumPy only, runs on any machine)
from underdog_woof import Woof
tts = Woof(weights="woof_int8.npz", voice="juno")
wav = tts("Hello from the reference engine.", seed=1)
Experimental MLX speech stage (not recommended, slower)
from mlx_woof import make_mlx_woof
tts = make_mlx_woof("woof_int8.npz", voice="juno")
Which engine should I use?
| Engine | Speech stage | Decoder | Speed vs reference | Audio vs reference | Use it for |
|---|---|---|---|---|---|
Woof (reference) |
NumPy | NumPy | 1.00x | is the reference | any platform, ground truth |
make_fast_woof(mlx_decoder=False) |
C, 2 threads | NumPy | 1.24-1.28x | bit-identical waveform | strict exactness on a Mac |
make_fast_woof |
C, 2 threads | MLX, GPU | 2.33-2.76x | within 1 PCM16 step | Apple Silicon default |
make_mlx_decoder_woof |
NumPy | MLX, GPU | 1.58-1.74x | within 1 PCM16 step | no compiler available |
make_mlx_woof |
MLX, GPU | NumPy | 0.70-0.75x | valid take, not sample-exact | research |
The "audio vs reference" column holds on text that upstream splits cleanly, or with fix_splitter=False. Every
engine here uses the splitter fix by default, and it changes the audio only for sentences where upstream would end a
piece mid-phrase. That is the point of it. The exactness gates build their engines with fix_splitter=False.
Requirements and limits
- Apple Silicon and macOS only. The C step links Accelerate and needs
clang(Xcode command line tools). - Bit-exactness depends on NumPy using Accelerate for float32 matrix products. That is the case for NumPy
2.5.4 on this machine (the only version I tested). On a NumPy built against another BLAS, the reference itself
would differ at the bit level. Run
python validate_fast.pyto check your setup. It reports a mismatch plainly. - The thread pool uses two cores while a synthesis runs and parks when idle. By design, one synthesis at a time gets the pool and a concurrent one runs serially with the same bits. I have not tested concurrent syntheses.
- Thread counts above 2 were slower in my measurement (see the benchmark notes). Do not raise it blindly.
- Peak memory and power were not measured.
Benchmarks
Single machine, warm, interleaved, so read them as a measurement on this host and not as a guarantee.
| Chip | Apple M4 Max (14 CPU cores), AC power |
| Software | macOS 26, Python 3.15.2, NumPy 2.5.4, MLX 0.32.4 |
| Host state | not idle: 1-minute load average 9.1 before and 3.1 after the run, on 14 cores. The script flags any run above its load threshold, and the starting figure still included earlier activity on the host. Screen streaming (WindowServer, Parsec) was active throughout. |
| Method | 9 rounds per row, first round discarded, engine order rotated each round, seed 17, wall time of the whole call (normalization, speech, decoder, retries, stall check) |
Median wall time, lower is better, speedup against the reference in brackets. "xRT" is seconds of audio per second of wall time.
| Voice / text | Audio | Reference | MLX decoder | C speech | C speech + MLX decoder | Paired wins (default) |
|---|---|---|---|---|---|---|
| Juno, short | 5.6 s | 310 ms (17.9 xRT) | 182 ms (1.71x) | 250 ms (1.24x) | 122 ms (45.6 xRT, 2.55x) | 9/9 |
| Juno, gate sentence | 7.5 s | 423 ms (17.7 xRT) | 247 ms (1.72x) | 341 ms (1.24x) | 157 ms (47.6 xRT, 2.69x) | 9/9 |
| Juno, 3 sentences | 9.0 s | 665 ms (13.5 xRT) | 419 ms (1.59x) | 520 ms (1.28x) | 285 ms (31.6 xRT, 2.33x) | 9/9 |
| Juno, long | 12.2 s | 687 ms (17.8 xRT) | 396 ms (1.74x) | 549 ms (1.25x) | 251 ms (48.8 xRT, 2.74x) | 9/9 |
| Mira, short | 7.2 s | 403 ms (17.9 xRT) | 237 ms (1.70x) | 316 ms (1.27x) | 151 ms (47.8 xRT, 2.67x) | 9/9 |
| Mira, gate sentence | 9.4 s | 535 ms (17.5 xRT) | 310 ms (1.73x) | 419 ms (1.28x) | 194 ms (48.4 xRT, 2.76x) | 9/9 |
| Mira, 3 sentences | 10.5 s | 1102 ms (9.5 xRT) | 697 ms (1.58x) | 862 ms (1.28x) | 446 ms (23.5 xRT, 2.47x) | 9/9 |
| Mira, long | 13.8 s | 783 ms (17.7 xRT) | 454 ms (1.72x) | 625 ms (1.25x) | 287 ms (48.2 xRT, 2.73x) | 9/9 |
MLX speech (the experimental engine) ran at 0.70-0.75x of the reference on every row and lost every paired round.
What the numbers say:
- The two stages were about equal. In the reference engine the speech stage takes about 50% of wall time and the decoder about 50%, on every row.
- The decoder moves to the GPU and the speech stage moves to compiled code. The decoder is a batch of large convolutions, so it suits the GPU. The speech stage is one latent frame at a time, so it is per-operation overhead that compiled code removes. Together they reach 2.33-2.76x.
- Threads help up to 2. Speech-stage time per 25 Hz frame on the gate sentence, one run at load about 2.5 to 3: NumPy 1.205 ms, C with 1 thread 0.970 ms, 2 threads 0.695 ms, 3 threads 1.202 ms, 4 threads 0.995 ms, 6 threads 0.775 ms. Every one of those runs was bit-identical to the reference. I did not isolate why 3 and 4 threads are slower than 1. Oversubscribed cores and efficiency-core scheduling are the likely causes, and that is a guess.
- The multi-sentence rows are slower per second of audio because the engine redraws a piece that runs long or stalls, up to three more times. That is the model's own retry rule.
- First call after construction (includes one-time MLX kernel compilation): Juno: reference 474 ms, mlx-decoder 281 ms, mlx-speech 566 ms, c-speech 346 ms, c-speech+mlx-decoder 185 ms. Mira: reference 520 ms, mlx-decoder 314 ms, mlx-speech 717 ms, c-speech 434 ms, c-speech+mlx-decoder 198 ms.
- The decoder fp32 choice is deliberate. fp16 and bf16 decoders were tried and rejected: the decoder time did not change (32 ms for all three on the gate sentence) and the error rose to 33 and 274 PCM16 steps.
The host was not idle, so treat the milliseconds as upper bounds and the speedups as the result. Not measured here: peak memory, power, and chips other than the M4 Max.
Reproduce it:
python benchmark.py # 5 rounds, both voices, 4 texts, writes evidence/benchmark.json
python benchmark.py --rounds 9 --voices juno --out evidence/my_run.json
The script prints the host load before and after and warns when the host is busy. Run it on AC power with nothing
else running, and keep other work off the machine: a busy host hurts the threaded engine most. The run behind this
table is evidence/benchmark_m4max.json, including the per-text stage split.
Sentence-splitter fix (on by default)
Upstream's sentence splitter can leave a piece that ends mid-phrase, and the model then tends to repeat its last words. Every engine in this repo includes a fix, on by default.
The bug. textsplit._split_conj cuts a piece that is over 120 characters and has no punctuation before a
conjunction near its middle. The left half can end on "...a final resting place for those" or "...we take increased
devotion to". The model was trained on utterances that end at punctuation. On Gettysburg sentence 3, Whisper hears
"for those for those" at the boundary on every seed I tried (0, 1 and 2). The retry check looks at silence and
length, and the bad take is the one returned each time, so it does not catch this.
The GitHub user Clay-Ferguson reported the problem in github.com/Clay-Ferguson/Buffy and worked around it with a preprocessor. I reproduced it. I did not run that preprocessor, and none of its code is used here.
The fix. The left half of each conjunction cut keeps a trailing comma, so every piece ends on punctuation. No cut position moves. Text that upstream splits cleanly comes out exactly as before, so its audio is unchanged.
The change lives in woof_split.py, which subclasses Woof and does not modify underdog_woof/. The same change as a
4-line patch against upstream's textsplit.py (revision be70296) is in splitter_fix.patch. Pass
fix_splitter=False to any factory for upstream's exact behavior.
Evidence. python evaluate_splitter.py synthesizes each line of two public-domain texts with both splitters,
transcribes the audio with whisper.cpp (base.en), and aligns the transcript with the source words. Insertions are the
telltale of a repeat. Substitutions are mostly the ASR model's own noise. Voice Juno, results in
evidence/splitter_asr.json.
| Text | Splitter | Clips | Words | Substitutions | Insertions | Deletions | WER | Mid-phrase pieces |
|---|---|---|---|---|---|---|---|---|
| Gettysburg Address | upstream splitter | 30 | 804 | 10 | 8 | 1 | 2.4% | 6 of 57 |
| Gettysburg Address | with the fix | 30 | 804 | 11 | 0 | 0 | 1.4% | 0 of 57 |
| Declaration of Independence | upstream splitter | 33 | 1335 | 20 | 2 | 5 | 2.0% | 3 of 101 |
| Declaration of Independence | with the fix | 33 | 1335 | 21 | 2 | 6 | 2.2% | 1 of 101 |
- Gettysburg: the failures are gone. Insertions fall from 8 to 0, on all three seeds, at the same two sentences.
- Declaration: no measurable change. 2.0% against 2.2% is three words out of 1,335, within ASR noise. Upstream left two truly broken pieces in 101 here, and neither produced a visible repeat. The one mid-phrase piece left in the fixed row is a heading in the input with no end punctuation, not a splitter cut.
python validate_splitter.pychecks the fix without weights. The fixed splitter differs from upstream only by trailing commas and leaves no piece ending mid-phrase. The five texts behind this repo's other gates and benchmarks are unaffected, so their evidence stands.evidence/splitter_before_after/has the two broken sentences rendered both ways, Juno, seed 0.
Limits. ASR judges words, not prosody. I have not judged how a pause after "devotion to," sounds, so listen to the clips. This is one machine, one voice, one ASR model and two texts. I did not test Mira or other kinds of text.
I also tried commas added up front by a small fitter of my own. It tied the one-line fix on Gettysburg and was slightly worse on the Declaration, so the simpler change is the default.
Accuracy
Run python validate_fast.py for the first group and python validate_mlx_decoder.py for the second. Neither uses a
tolerance where equality is possible.
Compiled speech step: array equality
- Free-running latents. Two voices x three texts x four seeds: 24 of 24 runs are
array_equalto the NumPy reference, including the digit-heavy sentence that makes the MLX speech stage diverge. - Thread counts. The same at 2, 3 and 4 threads: 0 runs differ.
- Teacher-forced latents. The reference's own latents fed back for 265 frames: identical.
- Mutation check. Changing the layer-norm epsilon from 1e-5 to 1.0001e-5 in a rebuilt copy of the C source makes 3 of 3 texts differ, and the script asserts the mutation applied. A pass therefore means the test reaches the code.
- Whole pipeline with the NumPy decoder. 24 of 24 waveforms (including normalization, chunking and retries) are
array_equalto the reference engine.
Why this was possible: each primitive was compared with NumPy first and matched bit for bit. np.exp on float32 is
plain libm expf here, np.sum is NumPy's pairwise summation (reproduced in woof_fast.c), and float32 matmul and
dot go to Accelerate's sgemv and sdot, which the C step calls directly. The build uses -ffp-contract=off so no
multiply-add is fused. Row-splitting a matrix-vector product across threads gives the same bits for every large
shape in this model (0 mismatches in 720 trials). It does not for the two tiny matrices, 448x32 and 32x320, so those
are never split.
MLX decoder: parity on identical latents
- Strict parity. MLX decoder against the NumPy decoder on the same latents: max abs error 9e-7 to 2.2e-6, against one PCM16 step of 3.05e-5.
- Mutation check. A shortened attention window (8) and a dropped ELU make the same gate fail at 8.6e-2 and 28.
- Whole pipeline. Two voices x four texts x three seeds (24 renditions): every one has the same sample count as the reference, and every PCM16 sample differs by at most 1 step (0.16% to 0.34% of samples, all rounding-boundary flips). The retry decisions match because the speech stage and its random stream are untouched.
Against upstream's own sample clips
python compare_upstream_samples.py renders the six clips upstream publishes at their published seeds and reports
correlation with the shipped WAVs (results in evidence/upstream_sample_comparison.json).
| Clip | Reference | C speech | C speech + MLX decoder | MLX speech |
|---|---|---|---|---|
| juno_0 | 0.999 | 0.999 | 0.999 | 1.000 |
| juno_1 | 0.546 | 0.546 | 0.546 | 0.570 |
| juno_2 | 1.000 | 1.000 | 1.000 | 1.000 |
| mira_0 | 0.939 | 0.939 | 0.939 | 0.963 |
| mira_1 | 0.750 | 0.750 | 0.750 | 0.641 |
| mira_2 | 0.947 | 0.947 | 0.947 | 0.925 |
The reference engine itself is not bit-exact to upstream's clips. This model's autoregressive trajectory is sensitive: the original run found that a one-latent perturbation of 1e-6 in pure NumPy reproduces the same mid-sentence divergence. A low correlation therefore means a different but valid take, not an error.
Read the table relatively. The two C speech columns equal the reference column on all six clips, with the same correlation and sample count. For C speech alone the max abs difference matches too. The MLX decoder alone matches as well. The MLX speech column sits in the same band as the reference but is not identical.
I also transcribed upstream's six clips and four of this repo's clips with Whisper (base.en). Each is one clean
rendition of its text, with no repeated words or sentences and no echo in the 30 to 400 ms range.
Why the MLX speech stage is not sample-exact. In the original run it matched the reference to 2e-5 when fed the
reference's latents (teacher-forced), at 8, 32, 96, 192 and 256 frames. That included layer-by-layer prefix and
KV-cache parity, so the implementation is right. Free-running, the end-of-speech logit is a noisy spike train and
the trajectory bifurcates. The stop frame and some mid-sentence latents then differ. mac_validate.py records both
statuses separately.
Evidence in evidence/ from the original M4 Max run that predates benchmark.py (mac_woof_*_v2.json,
mac_transcribe_report.json, mac_coreml_*.json) was not re-run for this release. Its two machine-specific paths
were removed and nothing else was changed. The parity_*.wav clips are the same sentence rendered by two engines,
kept for comparison, so playing them back to back sounds like a repeat by design.
Core ML flow-head experiment (negative result)
The conditioned single-frame flow head (10-15% of speech-stage compute) was exported to Core ML
(coreml_flow_head/woof_flow_head_fp32.mlpackage, with a torch-free exporter in coreml_flow_head_local.py).
python -m pip install 'coremltools==9.0'
python mac_coreml_validate.py # numerics: fp32 head vs NumPy, CPU_ONLY and ALL
python mac_coreml_validate_v2.py # numerics, MLComputePlan placement, latency, end to end
| Test | Result (M4 Max, macOS 26, coremltools 9.0) |
|---|---|
| Numerics, fp32 head vs NumPy | max abs about 8.3e-7, passes |
MLComputePlan placement |
fp32: Neural Engine unsupported. fp16: supported, but CPU preferred for every op |
| Per-call latency (n = 1000, interleaved) | NumPy head 183 us, Core ML ALL 135 us |
| End to end, head swapped into the loop | +8.4 ms slower (30 paired rounds, 95% CI +5.7 to +9.6 ms) |
Single-frame dispatch cannot amortize accelerator overhead, and no public API forces Neural Engine placement.
MLComputePlan is a planning estimate, not a utilization measurement. ANE would need a batched workload.
Validation scripts
| Script | What it checks | Runs on |
|---|---|---|
validate_splitter.py |
splitter fix: differs from upstream only by commas, no mid-phrase pieces, mutation | any |
evaluate_splitter.py |
ASR check of the splitter fix on real texts (needs whisper.cpp) | Mac |
validate_fast.py |
compiled step: array equality, threads, mutation, whole pipeline, timing | Mac |
validate_mlx_decoder.py |
decoder parity, mutations, 24-rendition whole pipeline, interleaved timing | Mac |
benchmark.py |
five-engine wall time, stage split, first-call cost | Mac |
compare_upstream_samples.py |
correlation with upstream's published clips | Mac |
mac_validate.py |
tensor integrity, flow head, layer and KV parity, teacher forcing, free-running | Mac |
mac_coreml_validate*.py |
Core ML numerics, placement, latency | Mac |
tensor_hash_reference.json |
SHA-256 of all 60 dequantized speech tensors | any |
bash run_mac.sh builds the extension, then runs the three gates, the benchmark, and mac_validate.py for both voices.
Where the remaining time goes
With the compiled step the speech stage is matrix-vector bound. I profiled it on a heavily loaded host, so read the
shares and not the milliseconds. 87% of the C step was in the 45 sgemv calls. The rest was attention,
normalization and the exponentials. That leaves little to take with exact numerics.
probes/gemv_probe.c times the same 45 products on one thread in C:
| Kernel (one frame, one thread) | Time |
|---|---|
| NumPy through Accelerate (separate measurement) | about 0.72 ms |
| naive NEON, fp32 weights | 1.13 ms |
| naive NEON, int8 weights, fp32 activations | 1.13 ms |
int8 weights, int8 activations (sdot) |
0.29-0.36 ms |
- Exact numerics are near the floor. A hand-written fp32 kernel does not beat Accelerate's
sgemv. The C step must call the same routine to stay bit-identical. The remaining exact lever is more parallelism, which stopped helping past 2 threads in my measurement. - The fast kernel changes the numerics. The
sdotkernel also quantizes each activation vector to int8. An independent ONNX conversion (see Related ports) found that dynamic INT8 compounds over the autoregressive frames, reaching 0.60 max sample error on a long sentence. I have not built this route and would not ship it without the teacher-forced and listening gates. - A GPU single-pass step would still be launch-bound, so it is not expected to beat the CPU. That is not measured.
- Batching independent streams would raise throughput for a server. It does not help single-stream latency.
A Rust and Metal implementation inside TurboSpark is planned, with the decoder first. It would be gated by the same tests: tensor hashes, teacher-forced latents, and decoder parity on identical latents. It is not released.
Related ports
Independent conversions on the Hub, listed for context. They are not endorsed here and I have not audited their code.
masterofaudio2077/underdog-woof-onnx: ONNX Runtime, fp32. Its ownbenchmark.jsonreports 1.08x over NumPy on a shared 16-core Linux CPU and calls that within noise. Its value is portability, not speed. It also reports that the base runtime does not reproduce upstream's shipped clips, and that dynamic INT8 degraded long-form quality.ldenoue/Underdog-Woof-WebGPU: an in-browser WebGPU port.
Repository layout
woof_int8.npz int8 checkpoint, byte-identical to upstream (SHA-256 in source_manifest.json)
underdog_woof/ original NumPy package, byte-identical to upstream
woof_fast.c, woof_fast.py compiled speech step (bit-identical), recommended
build_ext.sh builds libwoof_fast.dylib (never add -ffast-math)
woof_split.py splitter fix, on by default in every engine here
splitter_fix.patch the same fix as a 4-line patch against upstream's textsplit.py
validate_splitter.py splitter gate (pure Python, no weights)
evaluate_splitter.py ASR measurement of the splitter fix
texts/ public-domain texts for the splitter tests
mlx_decoder.py MLX audio decoder
mlx_woof.py experimental MLX speech stage
benchmark.py reproducible five-engine benchmark
validate_fast.py compiled step gate: array equality, threads, mutation, pipeline
validate_mlx_decoder.py decoder parity, mutation and pipeline gate
compare_upstream_samples.py comparison with upstream's sample clips
probes/gemv_probe.c C timing of the 45 speech matrix-vector products
mac_validate.py full qualification suite
coreml_flow_head/ exported Core ML flow head and manifest
coreml_flow_head*.py torch and torch-free exporters
mac_coreml_validate*.py Core ML numerics, placement and latency tests
mac_transcribe_check.py optional ASR intelligibility check (mlx-whisper)
tensor_hash_reference.json frozen SHA-256 of all 60 speech tensors
evidence/ reports and WAVs from the M4 Max runs
evidence/splitter_before_after/ the two broken Gettysburg sentences, upstream splitter vs the fix
License
Underdog Woof is released by Conway under the Underdog Non-Commercial License 1.0. LICENSE and NOTICE here
are byte-identical to upstream's and must stay unchanged. The short version, which does not replace the full terms:
- Free for non-commercial use (personal projects, research, teaching, non-profits). Commercial use needs a separate license from Underdog: license@conway.tech.
- Credit Underdog. Put "Underdog Woof" or "underdog.ai" in the title or description of anything you publish with its audio. Any app that uses it must show "Voice by Underdog Woof", linked to underdog.ai.
- No training on Woof. Do not use the model or its audio to train, fine-tune or distill another speech or audio model.
- Derivatives stay under this license. That includes converted versions and the code in this repo that is built on the model. Say what you changed. Do not use a different license for them.
- The audio decoder is adapted from Kyutai's Mimi (CC-BY 4.0). See
NOTICE.
What this repo changed: it adds woof_fast.c, woof_fast.py, woof_split.py, mlx_decoder.py, mlx_woof.py, the
Core ML export, the scripts, and the evidence files listed above. The weights and the original package are unchanged. The sample
WAVs in evidence/ are outputs of the model, published here with this credit: Underdog Woof, underdog.ai.
Provenance
Original model: ConwayResearch/Underdog-Woof, revision
be702960539777fc3f698e54335276a8391b00f9. source_manifest.json pins the checkpoint SHA-256
(d895fbbe...), and tensor_hash_reference.json freezes every dequantized speech tensor. No training,
fine-tuning, distillation or re-quantization was performed.
- Downloads last month
- 16
Model tree for cowWhySo/Underdog-Woof-MLX
Base model
ConwayResearch/Underdog-Woof