DVLCO – DV Language Composer Orchestra (Demo v1)

Nov 15, 2025

DVLCO – DV Language Composer Orchestra (Demo v1)

A first public demo for composing real music in DV Language

By Ronen Kolton Yehuda (MKR: Messiah King RKY)

For about two years I’ve been developing DV Language (David’s Violin Language) – a textual, intuitive way to write music, rhythm, percussion and more, designed for humans, computers, and AI at the same time.

Until now, most of it lived in articles, examples, and explanation posts.
Today, for the first time, there is something you can actually open and play with:

🎶 DVLCO – DV Language Composer Orchestra (Demo v1)
Meanwhile a browser-based music engine that reads DV notation and plays it as sound.

No installation. No account. Just open the page, paste or type DV notation, choose instruments, and press Play.

👉 Demo link: you can run it here in the browser:

DVLCO — DV Language Composer Orchestra (Demo v1)

(best on desktop / laptop with headphones)

What is DVLCO?

DVLCO stands for DV Language Composer Orchestra.

It’s a demo music workstation that:

Reads DV Language text (like | Do4Q , Re4Q , Mi4Q , Fa4Q |),
Uses Tone.js under the hood to synthesize sound,
Lets you build multiple channels (tracks) – each with its own instrument,
Supports orchestral instruments, piano, guitar, drums, cymbals and more,
Can export audio (MP3, or WAV fallback) and MIDI for further use in DAWs.

It is not a polished commercial DAW. It’s a living demo of how DV Language can be used as a serious, programmable music format.

Who is it for?

I built this demo for:

Composers & songwriters who like writing with text or code.
Music teachers & students who want a more logical, language-based notation.
Developers & AI researchers who want a clean text format for music.
DV Language readers who already follow my articles and want to hear it.

If you can type, you can start composing. If you already know DV Language – you’re 5 minutes from writing your first full piece in the app.

DV Language inside the Composer

The demo already supports a wide DV feature set:

1. Notes in multiple languages

You can write notes using DV syllables and also many localized names:

Do Re Mi Fa Sol La Si
Variants in Chinese, Korean, Japanese, Russian, Hindi, Thai, Vietnamese, Filipino, and accented Latin versions – all normalized internally.
Accidentals:
- # and ♯ are treated the same (sharp)
- b and ♭ are treated the same (flat)

So:

Do#4Q and Do♯4Q → same pitch, quarter note
Reb4E and Re♭4E → same pitch, eighth note

2. Western letters mapped into DV world

When you use Western note letters with octave and duration, the engine maps them into DV automatically:

C4Q → Do4Q

D4Q → Re4Q

E4Q → Mi4Q

F4Q → Fa4Q

G4Q → Sol4Q

A4Q → La4Q

B4Q → Si4Q

So you can freely mix:

| Do4Q , Re4Q , Mi4Q , Fa4Q |

| G4Q , A4Q , B4Q , C5Q ||

and everything stays coherent inside the DV system.

3. Durations, dots, tuplets, triplets

DV durations are fully supported in the demo:

W, H, Q, E, S, T → Whole, Half, Quarter, Eighth, Sixteenth, Thirty-second
Or as fractions: (1/1), (1/2), (1/4), (1/8), (1/16), (1/32)

You can also use:

Dotted notes: add * → Do4Q* (dotted quarter)
Tuplets / triplets: [i/n] →
- Do4Q[1/3], Do4Q[2/3], Do4Q[3/3] inside a triplet group
- Same logic applies to rests.

The timing is computed in ticks, with enough resolution for triplets and precise rhythms.

4. Bars (“boxes”) and repeats

Music is written inside boxes with |:

| Do4Q , Re4Q , Mi4Q , Fa4Q |
| Sol4Q , La4Q , Si4Q , Do5Q ||

The engine checks that each bar has the correct total duration (based on beatsPerBox).

You can also use simple repeat syntax:

|: ... :| → that section will be played twice automatically.

The parser expands repeats internally before scheduling playback.

Instruments, channels, and the “orchestra”

The “Orchestra” part of DVLCO is the multi-channel design:

Each channel = one track (instrument + DV text).
You can add as many as you want (practically limited by your browser / CPU).
Each channel has:
- Instrument selector
- Volume slider
- Mute button
- DV editor
- Buttons for:
  - Check channel
  - Play / Stop channel
  - Export channel (MP3/MIDI)
  - Print channel as PDF

Available instruments include:

Piano
Guitar
Harp
Violin, Viola, Cello, Contrabass, Strings
Flute, Oboe, Clarinet, Bassoon
Trumpet, Horn, Trombone, Tuba
Timpani, Drum, Cymbal, Triangle

Internally, each instrument is built on top of Tone.js synths, tuned to give:

Smoother envelopes for strings and winds
Pluck-like response for harp/guitar
Percussive behavior for drums and cymbals

You can then press “Play Orchestra” to play all active channels together.

Piano: two hands, one instrument

For Piano, the demo has a special role:

Piano is not just “another synth.”
Conceptually it represents two hands (right and left), like traditional notation.

In this first demo version:

Piano is still one channel in the UI,
But it is designed to make it easy to write right-hand and left-hand lines in DV language, parallel and separate – just like two staves in classical piano scores.
The engine already supports polyphony and chords (so full piano textures are possible).

Next steps (future versions, no commitment):

A dedicated “Piano 2-Staff mode” where:
- One logical Piano instrument exposes two synchronized DV editors (RH / LH),
- Both hands are played together, kept aligned by bar and timing.

Even now, you can simulate this by using two channels with Piano: one for RH, one for LH, and composing them bar-aligned.

Drums & Cymbals

The demo supports a drum mapping for DV-style drum symbols:

K – Kick
S – Snare
T1, T2, T3 – Toms
Rm – Rimshot
Cl – Clap
Hh – Hi-Hat closed
Ho – Hi-Hat open
Cr – Crash
Tr – Triangle-like metallic hit

These are mapped to internal percussion synths and MIDI drum notes.

A typical DV drum bar might look like:

| HhS , KQ , HhS , S Q |

And yes – drums and cymbals are explicitly named that way in the UI for clarity.

Rests, mutes, and full-bar silence

The engine supports:

Partial rests / mutes inside bars:
- RestQ, Rest(1/4)
- MuteE, Mute(1/8)
- 0Q, 0(1/4)
- Short forms like RQ, MQ, etc.
Full-bar mute by using one of:
- | R |, | M |, | Rest |, | Mute |, | 0 |, | MW |

The parser converts all of that into durations in ticks and ensures that each bar length still matches.

Chords: more than just single notes

DVLCO supports Western-style chord symbols with DV timing:

GQ → G major triad, quarter note

GmQ → G minor triad, quarter note

A#H → A♯ major triad, half note

CbE → C♭ major, eighth note

The basic format is:

Letter [# / b optional] [m / dim / aug / 7 / maj7 / m7 / sus2 / sus4 optional] Duration

Examples:

C Q, CmQ, CdimQ, CaugQ

F#7Q, F#m7H, Bbmaj7Q

Dsus2Q, Gsus4H

Internally, the engine expands these into intervals and plays them as polyphonic chords on poly instruments (piano, strings, etc.).

Currently supported chord types:

- **Major triads** – C, D, F#, Bb, etc.

- **Minor triads** – Cm, Dm, F#m, Bbm, etc.

- **Diminished triads** – Cdim

- **Augmented triads** – Caug

- **Seventh chords** – C7, Cm7, Cmaj7

- **Suspended** – Csus2, Csus4

Not yet supported in Demo v1 (future candidates, no commitment):

- **Half-diminished** – Cø, Cm7b5

- **Extended chords** – C9, C11, C13, Cadd9, altered 7ths (C7b9, C7#5, etc.)

If you need very complex harmony, you can always spell it explicitly with `+` groups, for example:

`Do4+Mi♭4+Sol♭4+Si♭4Q`

Here’s a single, clean section you can paste into the blog manual, covering all fake-sustain scenarios (with your Mi bass example included) and explaining same-time vs not-same-time in this context.

“Fake Sustain” for Single-Staff Polyphony (Demo v1 Limitation)

In traditional notation it is very common to have two voices on the same staff:

A long note that should keep ringing (pedal / cantus / sustained tone),
While shorter notes move above or below it on the same staff line.

In DVLCO – DV Language Composer Orchestra (Demo v1), the engine cannot yet let one note truly sustain independently inside the same box while other notes continue in the same DV line.

To still allow realistic classical-style writing in DV Language, Demo v1 uses a temporary “fake sustain” workaround.

Core rule – how the fake sustain behaves

When you write a + group like:

Do3W + Mi4Q

in Demo v1:

The duration before + (W on Do3W) is kept for notation only
→ in DV score / export / printing, this pitch is understood as a long note.
The actual audio duration follows the group duration
(taken from the “outer” duration, usually the second note, e.g. Q on Mi4Q)
→ in playback, the group behaves like a quarter-note chord at that position.

Because of this, you can already write correct DV notation (with a sustained voice and inner motion),
even though the demo engine plays a simplified sustain.

The examples below show:

Notes sounding at the same time (using +), and
Notes sounding at different times in the same box,
all using this fake-sustain logic.

Scenario 1 – Pedal tone + moving line (4/4, same-time start)

Musical idea (single staff, two voices):

Time signature: 4/4.
Lower voice: Do₃ written as a whole note (pedal through the bar).
Upper voice: four quarter notes, for example Mi₄ – Fa₄ – Sol₄ – Mi₄.

In traditional notation you would see:

Stem-down Do₃ as a whole note,
Stem-up Mi₄, Fa₄, Sol₄, Mi₄ as four quarter notes above it.

Conceptual bar in “plain words”:

| Do3W ; Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q ||

This is the musical idea, but it doesn’t fit the DV timing rules, because Do3W on its own already fills the 4/4 box.

DV Language in DVLCO (using fake sustain):

| Do3W + Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q ||

DV interpretation (what you mean):

Do3W – bass Do₃ is a whole-note pedal for the bar.
Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q – the moving line in quarter notes.

What Demo v1 actually does:

It remembers W on Do3W for DV notation / print
→ in DV score you still read “Do₃ whole note (pedal)”.
For timing, it uses the group duration Q from Mi4Q
→ Do3W + Mi4Q is played as a quarter-note chord at the start.
The rest of the bar (Fa4Q ; Sol4Q ; Mi4Q) fills the remaining 3 beats.

Result:

Musically: “Do₃ is a whole-note pedal + Mi₄–Fa₄–Sol₄–Mi₄ on top” (classical texture).
Technically: one DV box with 4×Q, valid in Demo v1.

This shows how to keep the notation correct and the audio usable when
the sustained note and the first moving note start at the same time.

Scenario 2 – Sustained top note + inner motion (same-time start)

Now the sustained voice is on top and the inner notes move underneath.

Musical idea (single staff, two voices):

Time signature: 4/4.
Upper voice: Sol₅ as a dotted half note (sustained across most of the bar).
Inner voice: three quarter notes, for example Mi₅ – Fa₅ – Mi₅, plus another quarter to close the bar.

Conceptual bar:

| Sol5H* ; Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q ||

Again, this is not valid timing for the engine, because Sol5H* hangs over most of the bar by itself.

DV Language in DVLCO (using fake sustain):

| Sol5H* + Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q ||

DV interpretation (what you mean):

Sol5H* – notation: dotted half-note Sol₅ (sustained top voice).
Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q – quarter-note motion in the inner voice.

What Demo v1 actually does:

H* on Sol5H* is stored for notation – DV clearly marks it as a long note.
Timing again follows the group duration Q:
→ Sol5H* + Mi5Q plays as a quarter-note chord at beat 1.
The remaining three quarters (Fa5Q ; Mi5Q ; Sol5Q) play in sequence.

Result:

Notation: long top note + inner motion (typical classical single-staff polyphony).
Audio: simplified sustain, but the pattern is clearly audible.

Scenario 3 – Bass fills the bar, upper voice starts later (not same-time start)

Sometimes the idea is:

“Mi₃ is a whole-note pedal for the bar,
but the upper voice starts only later, not on the very first beat.”

Musical idea in plain words:

| Mi3W ; Fa4Q ; Sol4Q ; Mi4Q ||

Mi3W – pedal Mi₃ belonging to the whole bar.
Fa4Q ; Sol4Q ; Mi4Q – upper line entering from beat 2 onward.

This cannot be played literally as DV timing, because Mi3W already uses the full box.

DV Language in DVLCO (fake sustain with “silent” timing helper):

| Mi3W + Mi3Q ; Fa4Q ; Sol4Q ; Mi4Q ||

How to read this:

Mi3W – tells the score: “Mi₃ is a whole-note structural bass.”
Mi3Q – gives the first group an effective quarter duration (beat 1).
Fa4Q ; Sol4Q ; Mi4Q – the three quarters on beats 2, 3, 4.

What Demo v1 does:

Keeps W on Mi3W for notation (Mi₃ is visually a whole note tied to the bar).
Uses Q from Mi3Q for time:
→ Mi3W + Mi3Q is played as a quarter on beat 1.
Then Fa4Q ; Sol4Q ; Mi4Q fill the remaining 3 beats.

Musically, you still think:

“Mi₃ belongs to the full bar (pedal),
the upper notes start later and move above it.”

Technically, the bar is a valid:

Q + Q + Q + Q  = 4/4

This is the pattern to use when your sustained note belongs to the whole bar,
but the upper line does not start together with it.

Scenario 4 – Sustained voice that reappears later (not same-time + re-strike)

A more advanced texture:

One pitch is conceptually sustained for the whole bar,
but you re-strike it later inside the same box while other notes also move.

For example, a bar where Mi₃ is the structural bass of the bar,
but you hit it again with another chord in the middle:

Musical idea (concept):

Time signature: 4/4.
Structural bass: Mi₃ “belongs” to the whole bar.
On beat 1: Mi₃ + Mi₄.
On beat 3: Mi₃ + Sol₄.
Other beats filled with motion.

DV Language (one possible fake-sustain encoding):

| Mi3W + Mi4Q ; Fa4Q ; Mi3Q + Sol4Q ; Mi4Q ||

Interpretation:

Mi3W – DV notation: Mi₃ is a whole-note bass for the bar.
Group 1: Mi3W + Mi4Q → beat 1 (Mi₃ with Mi₄).
Group 2: Fa4Q → beat 2.
Group 3: Mi3Q + Sol4Q → beat 3 (Mi₃ re-struck with Sol₄).
Group 4: Mi4Q → beat 4.

What Demo v1 does:

Uses the group durations (all Q) for time.
Keeps the W on the first Mi₃ to mark it as a whole-bar structural tone in notation.
Lets you re-hit Mi₃ later (Mi3Q + Sol4Q) without breaking timing.

Total: 4 groups of Q → valid 4/4 box, but DV text clearly shows the long bass idea plus the re-strikes.

Summary – Playing at the same time vs not at the same time

Within this fake sustain framework:

Notes at the same time
→ use + groups:
Do3W + Mi4Q (pedal + moving voice on the same beat)
Mi3Q + Sol4Q (re-strike with chord).
Notes at different times in the same box
→ write them as separate groups in sequence, with correct durations:
... ; Fa4Q ; Sol4Q ; Mi4Q etc.

The fake sustain part is only about:

A long “notation duration” before + (W, H, H*, …),
Combined with a shorter “audio duration” after + (Q, E, …),
So the box timing works, but the DV text still remembers the long idea.

Practical rules for composers (Demo v1 only)

Whenever you want two voices on the same staff inside a single DV box:

Put the true musical duration (for notation) before the +
- Example: Do3W, Sol5H*, Mi3W…
Put the effective timing duration for that beat after the +
- Example: Mi4Q, Mi5Q, Mi3Q…
Make sure the sum of all group durations in the box matches the box capacity
- For 4/4: Q + Q + Q + Q in ticks.

So boxes like:

| Do3W + Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q ||
| Sol5H* + Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q ||
| Mi3W + Mi3Q ; Fa4Q ; Sol4Q ; Mi4Q ||
| Mi3W + Mi4Q ; Fa4Q ; Mi3Q + Sol4Q ; Mi4Q ||

are:

Valid DV boxes in Demo v1,
Readable as classical single-staff polyphony,
Pass timing validation,
Playable as reasonable audio demos.

🛠 Important note (Demo v1 only)

The duration before + is kept for notation / future engraving / export.
The audio timing always follows the outer group duration (the effective duration in the box).

In future versions, the goal is to:

Let long notes truly sustain independently inside the same box,
Handle pedal / overlay behavior inside the engine, without these manual tricks.

Until then, this fake sustain workaround already proves that:

Traditional two-voice writing on one staff
can be written, read, and printed in DV Language today,
even inside DVLCO – Demo v1.

Slides, groups, and articulation markers

The engine already understands some expressive details:

Slides

You can write slides as:

Do4E-S-Mi4E

This means: play Do4 for an eighth, then slide into Mi4 for another eighth.
The engine treats this as two sequential notes with the correct timing.

“+” groups (simultaneous events)

You can group notes with + to play them at the same time:

Do4Q+Mi4Q+Sol4Q

This is a chord in DV spelling. The demo enforces that you don’t mix drums and pitched notes in the same + group, to keep things clean.

Bows and fingering (ignored for sound but accepted in text)

For string instruments (violin, viola, etc.) and guitar, you can write:

Bowing direction and articulation:
- > = down-bow
- < = up-bow
- - = same bow / tie
- ^ = accent

And fingering before the note (sometimes with an extra letter for right hand / technique):

3>Fa4E → finger “3”, down-bow, note Fa4E
3Fa4E → finger “3”, note Fa4E
3iSol4Q → guitar fingering, “3i” before Sol4Q

In Demo v1:

The numbers and fingering letters are ignored by the sound engine,
The bow markers (> < ^ -) are recognized and preserved internally for future expressive logic,
So the following all still play correctly:
- V| >Sol1Q , <La1Q , >Si1Q |
- FingerNoteDuration: 2>Fa4E ; 1<Mi4E ; 0>Do4E | 3<La4E ; 2>La4E ; 0<Sol4E

In simple words:
You can already write full DV notation with bowing and fingering, and the engine will not break – it just treats those as annotations for now.

Export: MP3 (or WAV) and MIDI

One of the strongest parts of DVLCO is that it is not a closed toy.
You can export your work:

Per-channel export

For each channel:

Export Channel (MP3) 💾
- The engine renders your channel offline,
- Encodes to MP3 using lamejs if available,
- If MP3 encoding isn’t available, it falls back to WAV.
Export Channel (MIDI) 🎼
- Generates a .mid file with note-on / note-off events,
- Pitched instruments on a melodic channel (e.g., channel 0),
- Drums mapped to the standard drum channel (MIDI channel 10).

Full mix export

At the top level, you can also:

Export the full orchestra mix as audio (MP3/WAV),
Export the entire session as one MIDI file with multiple MIDI channels.

This means you can:

Compose in DV Language inside the browser,
Export to MIDI,
Open the MIDI in your DAW (Cubase, Logic, Ableton, Reaper, etc.),
Replace the demo sounds with professional libraries.

Printing and documentation

The demo adds a practical feature for teachers and students:

Print Channel (PDF) – opens a new window with:
- Title + channel number,
- Instrument name,
- The DV notation as monospaced text, ready to print or save as PDF.
Print All Channels (PDF) – one document with:
- A title page for DVLCO,
- Each channel, its instrument, and its DV text.

This is useful if you:

Want to keep a printed DV score,
Want students to have a worksheet in DV Language,
Or just want a local copy of your work.

Settings: tempo, beats per box, validation

At the top of the app, you can set:

Beats per box (default 4),
Tempo (BPM).

The engine:

Shows the current box capacity in ticks,
Validates each bar to make sure:
- The total ticks match the box capacity,
- If not, it tells you:
  Box X has Y ticks, needs Z ticks.

There’s also:

Check Channel ✔ – to verify syntax and timing for one channel,
Check All Channels ✔ – to validate the entire orchestra.

What this is – and what it is not (yet)

DVLCO – DV Language Composer Orchestra (Demo v1) is:

A first public demo, not a finished product.
A proof of concept that:
- DV Language can be parsed robustly,
- Complex rhythms (dots, tuplets), chords, drums, and multi-language notes all work together,
- The same text can be:
  - Played in the browser,
  - Exported to MP3/WAV,
  - Exported to MIDI,
  - Printed as PDF.

Features will continue to evolve:

More chord types (diminished, 7ths, etc.),
More realistic instruments,
Deeper handling of bow direction, accents, and articulation,
Degrees (1, 2, 3, 4, 5, 6, 7) as a first-class DV input mode.

I do not promise any specific release schedule. I’m an independent creator working with AI tools, improving this step by step, like a living lab.

How to use it

Open the demo in a browser:

https://dv-language-composer-orchestra-demo.pages.dev/

Plug in headphones or speakers.
Use the default channel or add more channels.
Paste something simple, for example:

| Do4Q , Re4Q , Mi4Q , Fa4Q |
| Sol4Q , La4Q , Si4Q , Do5Q ||

Click Check Channel – make sure it says DV OK.
Click Play Channel and listen.
Start exploring:
- Try GQ, GmQ, C4Q, C#4Q, Do♯4Q,
- Try a drum pattern,
- Try two channels with different instruments,
- Try exporting audio / MIDI.

Final note

DV Language is meant to be a bridge:

Between traditional music and modern technology,
Between human-readable notation and AI-readable structure,
Between text and sound.

DVLCO – DV Language Composer Orchestra (Demo v1) is the first time this bridge is actually playable by anyone with a browser.

If you do try it and you write a piece, arrangement, study, or just a small experiment in DV Language using this demo – that already means a lot to me.

👑🎶
Ronen Kolton Yehuda (MKR: Messiah King RKY)
Creator of DV Language and DVLCO Demo v1

DVLCO – DV Language Composer ORCHESTRA Demo v1

The DV language: David’s Violin Language

The DV Language 📜 - Ronen Kolton Yehuda

The Integration of DV Language with AI: From Teaching Instruments to Creative Machines 🎶🤖

Music Theory with DV Language 📘 By Ronen Kolton Yehuda (MKR: Messiah King RKY) with the assistance of AI

Digital Music Instruments i developed - Messiah King RKY (Ronen Kolton Yehuda) — Digital and Hybrid Musical Instruments Catalogue

Authored by: Ronen Kolton Yehuda (MKR: Messiah King RKY)

Check out my blogs:

Substack: ronenkoltonyehuda.substack.com

Blogger: ronenkoltonyehuda.blogspot.com

Medium: medium.com/@ronenkoltonyehuda

Authored by: Ronen Kolton Yehuda (MKR: Messiah King RKY)

Check out my blogs:

Substack: ronenkoltonyehuda.substack.com

Blogger: ronenkoltonyehuda.blogspot.com

Medium: medium.com/@ronenkoltonyehuda

DVLCO – DV Language Composer Orchestra (Demo v1)

Compose music in DV Language directly in your browser

By Ronen Kolton Yehuda (MKR: Messiah King RKY)

1. Why I Built This

For a long time I’ve been developing DV Language (David’s Violin Language) – a textual, intuitive way to write music, including notes, rhythm, percussion, bow directions, and later also dance and theater.

Until now, DV Language mostly lived in articles and examples: you could read it, understand it, maybe even imagine the sound—but you couldn’t just paste it into a tool and hear it.

So I decided to build a first demo:

A small “orchestra in the browser” that understands DV text and plays it back.

That demo is what I call:

DVLCO – DV Language Composer Orchestra (First Edition Demo).

It is not a finished DAW, not a commercial product, and not a promise of any final feature set.

It is a working experiment that I improve gradually: when something doesn’t work or is missing, I update the code and move on.

This article is a human-style overview of the software.

Below it (in my blog) I will attach the full technical manual for people who want every detail.

2. What DVLCO Actually Does

In simple words:

You open a web page.
You get several channels (tracks).
In each channel you write DV notation as text, inside boxes like:
| Do4Q , Re4Q , Mi4Q , Fa4Q |
You assign each channel an instrument (Piano, Guitar, Strings, Drums, etc.).
You press Play – and you hear your DV text.

On top of this, the demo already supports:

Multiple channels playing together (a small orchestra).
Triplets and tuplets (using [i/n] tags).
Chords (both DV-style and Western-style, e.g. C, Cm).
Drums and cymbals using short DV codes.
Slides between notes.
Rests and full-bar mutes.
Repeats using |: … :|.
Export of:
- Audio – mix or per-channel (MP3 by default, WAV fallback).
- MIDI – mix or per-channel (standard .mid files).
- Print/PDF – DV text formatted for printing.

It is all built around one idea:

DV Language is the primary score.
The software is the interpreter.

3. Writing Music as DV Text

DVLCO uses boxes separated by | characters, like a timeline:

| Do4Q , Re4Q , Mi4Q , Fa4Q |

| Sol4Q , La4Q , Si4Q , Do5Q ||

Each box has a fixed duration, controlled by Beats per Box.
Default is 4 beats, so 1 box = 4 quarter notes.
The software checks that every box is filled correctly: not too short, not too long.
If a box doesn’t match its capacity, you get a clear error, e.g.:
Box 2 has 60 ticks, needs 96.

This is important:

The program is not only a player; it is also a guardian of rhythmic correctness in DV notation.

Temporary workaround – “fake sustain” inside the box (demo limitation)

In this demo version, the engine does not yet support real pedal / independent long-note sustain inside the same box.
To still write correct DV notation and get reasonable playback, you can use the following temporary workaround:

1. Long note + shorter notes in the same moment

If you want a bass note to last longer (for notation), but the engine only plays short values, you can write:

| Mi3W + Mi3S ; Mi3E* ; Mi5Q ; Mi5Q ; Mi5Q ||

Notation meaning (DV / score):
- Mi3W = should last the whole bar.
- Mi3S = helper value so the box DV still looks complete.
Demo playback:
- The engine treats Mi3W+Mi3S as a normal chord with the group duration (the outer duration, for example Q),
  so the real audio is short – but the text still remembers the “W” for future proper score export.

2. Long bass + chords in the same box

You can also write a long bass note plus chords in the same box, for example:

| Mi3H + Mi5Q ; Mi5Q ; Mi3H + Sol5H + Sol6Q ; Mi5Q ||

Notation meaning:
- Mi3H = half-note bass.
- Mi5Q, Sol5H, Sol6Q = upper voices with their proper written durations.
Demo playback:
- The engine uses the outer duration of each group for timing,
  but your DV text already keeps the “true” durations (H, Q, etc.) for later engraving.

🛠 Important note (demo only):

In this first demo:
- The duration before + is kept for notation, but the audio follows the outer group duration.
- This is only a temporary solution so composers can already:
  - Write correct DV notation inside the box, and
  - Still get a workable demo playback.

In future official versions (or a more advanced demo), we will try to fix this properly so that:

Long notes can really sustain independently inside the same box,
And pedal/overlay behavior will be handled automatically by the engine, not by these manual tricks.

4. Notes, Languages, Sharps, and Flats

This Version currently Supported Note Languages & Scripts

This demo supports DV Language solfège note names in several scripts:

English / Latin-based: Do Re Mi Fa Sol La Si/ C D E F G A B
French / Spanish / Portuguese (accented): Dó Ré Mí Fá Sol Lá Sí (unaccented Do Re Mi … also works)
Filipino / Tagalog: Do Re Mi Fa Sol La Ti (Ti is interpreted as Si)
Chinese: 哆来咪发唆拉西
Korean: 도 레 미 파 솔 라 시
Japanese: ドレミファソラシ
Russian: До Ре Ми Фа Соль Ля Си
Hindi: सा रे ग म प ध नि
Thai: โด เร มี ฟา ซอล ลา ซี
Vietnamese: Đô Rê Mi Fa Sol La Si

The core DV note names are:

Do, Re, Mi, Fa, Sol, La, Si

In the demo they can appear in many languages and scripts and are all normalized internally. For example, the tool understands variants like:

Do, do, DO, C
哆 (Chinese)
도 (Korean)
ド (Japanese)
До (Russian)
Ré, Mi, Fá, Lá, Sí, etc.

All of them map back to the canonical DV names: Do / Re / Mi / Fa / Sol / La / Si.

A note is written as:

Name Octave Duration

Examples:

Do4Q – Do in octave 4, quarter note.
Sol5H – Sol in octave 5, half note.
La3E – La in octave 3, eighth note.

Accidentals

Sharps and flats are flexible:

Sharp: # or ♯ → both mean the same.
Flat: b or ♭ → both mean the same.

Examples:

Do#4Q = Do♯4Q
Reb4Q = Re♭4Q

Internally they become # or b and shift the semitone count accordingly.

Western Letters (C, D, E, …)

The engine also recognizes Western letters in certain contexts:

In chord symbols: C, Cm, G#, Gm, etc.
Inside some “+” groups as individual notes (C+E+GQ).

The long-term plan (already partially reflected in the code logic) is:

When you write C4, D4, E4, F4, G4, A4, B4, they are interpreted as
Do4, Re4, Mi4, Fa4, Sol4, La4, Si4 in the DV internal system.

This means DV and Western note letters become two “faces” of the same pitch world.

In this demo, the main focus is still on DV names, but the mapping of letters → DV pitches is already taken into account when possible.

5. Rhythm, Dots, and Triplets

Durations use simple symbols:

W – whole (1/1)
H – half (1/2)
Q – quarter (1/4)
E – eighth (1/8)
S – sixteenth (1/16)
T – thirty-second (1/32)

And also fraction style:

Do4(1/4) instead of Do4Q
Re4(1/8) instead of Re4E

You can add a dot with *:

Do4Q* – dotted quarter.
RestE* – dotted eighth rest.

For triplets and tuplets, the demo uses:

[ i/n ]

For example, a triplet inside a quarter:

Do4[1/3]Q
Re4[1/3]Q
Mi4[1/3]Q

All three divide one quarter note into 3 equal parts.

The internal timing uses 24 ticks per quarter, so triplets are exact.

6. Rests, Mutes, and Full-Box Silence

You can write partial rests in several ways:

RestQ, Rest(1/4)
MuteE, Mute(1/8)
0Q, 0(1/4)
Short forms: RQ, RH, RE, MQ, etc.

In addition, there is a full-box mute syntax:

| R |

| M |

| Rest |

| Mute |

| 0 |

| MW |

All of these mean: “this whole bar/box is silence”.

The software distinguishes between full-box muters (no duration inside) and partial rests (with explicit duration).

7. Fingering and Bow Directions (Ignored in Sound, Preserved in Text)

One of the important DV ideas is that you can write fingering and bow directions directly inside the text:

Examples:

>Sol4Q , <La4Q , >Si4Q
2>Fa4E ; 1<Mi4E ; 0>Do4E
3iDo4Q, 3iSol4Q (guitar fingering style)
FingerNoteDuration: 2>Fa4E ; 1<Mi4E ; 0>Do4E | 3<La4E ; 2>La4E ; 0<Sol4E

In this demo:

Fingering numbers and small letters at the start are ignored for sound.
- 3>Fa4E → plays Fa4E, bow > kept as metadata.
- 3Fa4E → plays Fa4E.
- 3iDo4Q → plays Do4Q.
- 3iSol4Q → plays Sol4Q.
Bow symbols are preserved:
- > – down-bow
- < – up-bow
- ^ – accent
- - – same bow / tie

The audio engine right now does not change the sound based on these bow marks, but they are kept in the parsed structure so later I can add articulation logic for strings and other instruments without changing your DV text.

In other words:

You can already write your DV lines with fingering and bow as you like, and the software will still play the correct pitches.

8. Chords, Groups, and Harmony

There are two main ways to get harmony.

8.1 “+” Groups (DV-style polyphony)

You can join notes with + to play them together:

Do4+Mi4+Sol4Q

This is a triad (chord) written explicitly by pitch.

Rules:

All items must be either notes or drums, but not mixed together.
If you write both drums and notes inside the same + group, the parser rejects it.

You can also use some Western letters inside groups:

C+E+GQ

The engine treats these letters as pitch names near middle C.

8.2 Western Chord Symbols

The software also supports Western-style chord symbols as single tokens:

CQ → C major triad

CmQ → C minor triad

CdimQ → C diminished triad

CaugQ → C augmented triad

C7Q → C dominant seventh

Cm7Q → C minor seventh

Cmaj7Q → C major seventh

Csus2Q → C suspended 2

Csus4Q → C suspended 4

General pattern:

Letter: A–G

Optional accidental: # or b

Optional quality:

- `m` → minor

- `dim` or `°` → diminished

- `aug` or `+` → augmented

- `7`, `maj7`, `m7` → seventh chords

- `sus2`, `sus4` → suspended chords

Then duration: Q, H, E, etc.

Internally, the engine builds an interval set for each type, for example:

- Major: 0, 4, 7

- Minor: 0, 3, 7

- Diminished: 0, 3, 6

- Augmented: 0, 4, 8

- 7: 0, 4, 7, 10

- maj7: 0, 4, 7, 11

- m7: 0, 3, 7, 10

- sus2: 0, 2, 7

- sus4: 0, 5, 7

Not yet supported (Demo v1):

- Half-diminished (ø, e.g. Cm7b5)

- Extended chords (9, add9, 11, 13, altered 7ths like C7b9, C7#5, etc.)

For those, you can spell the chord manually with `+` groups (e.g., `Do4+Mi♭4+Sol♭4+Si♭4Q`)..

9. Drums and Cymbals

Drums work with short DV-style codes, for example:

K – Kick
S – Snare
T1 – High tom
T2 – Mid tom
T3 – Low tom
Rm – Rimshot
Cl – Clap
Hh – Closed hi-hat
Ho – Open hi-hat
Cr – Crash
Tr – Triangle/bell style

You add durations as usual:

KQ ; S(1/8) ; HhE ; CrQ

Internally:

Drums use synthesizers adapted to percussion (MembraneSynth, MetalSynth).
In MIDI export, they map to standard General MIDI drum notes on channel 10.

The drum instruments themselves are selected by choosing Drum, Timpani, Cymbal, or Triangle as the channel instrument.

10. Instruments, Channels, and Piano

Each channel has an Instrument menu.

The demo includes:

Keyboard (Default) – neutral melodic synth.
Piano
Guitar
Harp
Strings and specific string instruments (Violin, Viola, Cello, Contrabass).
Winds (Flute, Oboe, Clarinet, Bassoon).
Brass (Trumpet, Horn, Trombone, Tuba).
Timpani / Drum / Cymbal / Triangle.

All melodic instruments run on a polyphonic synth, so chords and + groups play correctly.

Drums use dedicated drum synths.

Piano, Two Hands

The musical goal for piano is:

To be able to write right hand and left hand separately—like a traditional piano score—and have them play together.

Practically, in this demo you can already do it like this:

Channel 1: Piano – right hand DV text.
Channel 2: Piano – left hand DV text.
Press Play All to hear both hands together.

Later, the UI can evolve to a more explicit “Piano / RH / LH” mode, but the DV notation itself is already usable: you simply split the hands into two channels.

11. Export: Audio, MIDI, and Print

11.1 Audio Export (MP3 and WAV)

DVLCO can export:

Full mix – all non-muted channels together.
Per channel – one instrument line.

Internally it uses Tone.Offline to render the mix into an AudioBuffer, then:

If lamejs (MP3 encoder) is available, it encodes to MP3.
If not, it falls back to WAV.

So in many cases, you will see MP3 files being downloaded.

If you prefer always-WAV, that’s a small code change (use only the WAV path).

11.2 MIDI Export

You can export:

Channel MIDI – one .mid per channel.
Full mix MIDI – one .mid containing all channels.

The MIDI is standard:

Uses channels 0–15 (9 reserved for drums).
Writes proper Note On / Note Off with deltas.
Embeds tempo and track name.

You can open the .mid files in DAWs, notation programs, or other tools.

11.3 Print / PDF

Print Channel – opens a clean page with:
- Title
- Instrument name
- DV text block
Print All – opens a page containing all channels one after another.

From there you use your browser’s print dialog (and “Save as PDF” if you want).

12. What Is Stable, What Is Experimental

Stable enough for a demo:

Basic DV notes (Do, Re, Mi…) with octaves and durations.
Multi-language aliases for note names.
Sharps and flats with # / ♯ and b / ♭.
Boxes, beats-per-box checking, and time validation.
Rests, full-box mutes.
Simple chords (major/minor triads).
Drums and cymbals via codes.
Slides as two sequential notes.
Triplets / tuplets with [i/n].
Fingering numbers and letters ignored safely for sound.
Bow directions kept as metadata.
Multi-channel playback and muting.
Audio export (MP3 / WAV).
MIDI export (per channel + full mix).
Print / PDF views.

Experimental / open for change:

Detailed piano two-hand UX.
Advanced chords (dim, 7ths, etc.).
Complete support for Western letter notes in all contexts.
Interpreting bow direction in the sound itself (not just text).
Integration of musical degrees and more complex DV features.
More realistic, sample-based instruments.

Everything here is work-in-progress. The spirit of the project is:

I don’t commit to a final shape.
I let the system grow, and I update whatever doesn’t work or needs to be better.

13. Final Words

DVLCO – DV Language Composer Orchestra is:

A first working bridge between DV Language and sound.
A way to compose in text and hear the result immediately.
A demo that is already practical for experiments, studies, and early compositions.

If you want to go deeper into every command, every token, and every corner of the system,

I invite you to continue reading the full technical manual below this article in my blog.

There you will find:

Detailed rules for parsing.
All supported syntax.
Internal timing logic.
Export details, chords behavior, and more.

For now, if you are reading this on my blog:

Scroll down – the full DV Language Composer Orchestra manual follows after this article.

DVLCO – DV Language Composer ORCHESTRA Demo v1

The DV language: David’s Violin Language

The DV Language 📜 - Ronen Kolton Yehuda

The Integration of DV Language with AI: From Teaching Instruments to Creative Machines 🎶🤖

Music Theory with DV Language 📘 By Ronen Kolton Yehuda (MKR: Messiah King RKY) with the assistance of AI

Digital Music Instruments i developed - Messiah King RKY (Ronen Kolton Yehuda) — Digital and Hybrid Musical Instruments Catalogue

Authored by: Ronen Kolton Yehuda (MKR: Messiah King RKY)

Check out my blogs:

Substack: ronenkoltonyehuda.substack.com

Blogger: ronenkoltonyehuda.blogspot.com

Medium: medium.com/@ronenkoltonyehuda

Authored by: Ronen Kolton Yehuda (MKR: Messiah King RKY)

Check out my blogs:

Substack: ronenkoltonyehuda.substack.com

Blogger: ronenkoltonyehuda.blogspot.com

Medium: medium.com/@ronenkoltonyehuda

DVLCO – DV Language Composer Orchestra

First Edition Demo (v1)

By Ronen Kolton Yehuda (MKR: Messiah King RKY) with the assistance of AI

1. Introduction – What Is DVLCO?

DVLCO – DV Language Composer Orchestra is a browser-based music tool that lets you compose and play music using DV Language text.

Instead of writing scores in traditional notation, you type text like:

| Do4Q , Re4Q , Mi4Q , Fa4Q |

| Sol4Q , La4Q , Si4Q , Do5Q ||

DVLCO reads the DV text, checks the rhythm, and plays it back through virtual instruments (piano, guitar, strings, drums, etc.). You can:

Work with multiple channels (like a small orchestra).
Use DV note names in multiple languages (Do, 哆, До, 도, etc.).
Write chords, drums, slides, triplets, rests, repeats, and more.
Export audio (MP3 or WAV) and MIDI.
Print your DV text as a PDF-friendly page.

This is an experimental demo.

Some features (triplets, articulations, two-hand piano, advanced chords) are still evolving. There are no promises or commitments about stability or final behavior. The idea is simple: I fix, improve, and extend what doesn’t work well, step by step.

2. Technical Requirements

A modern browser (Chrome / Edge / Firefox).
JavaScript enabled.
Internet access if you load Tone.js and (optionally) lamejs from a CDN.

The engine uses:

Tone.js – for audio synthesis, timing, and offline rendering.
lamejs (optional) – for MP3 export.
If lamejs is not loaded, the app falls back to WAV export.

3. Layout Overview

When you open the DVLCO page you see:

Global Settings
- Beats per Box (beatsPerBox) – how many quarter-note beats in each box (| ... |).
  - Default: 4 (4/4).
- Tempo (BPM) – playback tempo.
  - Default: 80 BPM.
- A status line shows:
  Box capacity: <beatsPerBox> quarter beats = <ticks> ticks • Tempo <BPM>
Global Buttons
- Add Channel – creates a new instrument channel.
- Check All – validates DV text in all channels.
- Play All – plays all non-muted channels together.
- Stop All – stops everything.
- Export Mix (MP3/WAV) – exports full audio mix.
- Export Mix (MIDI) – exports a full orchestral MIDI file.
- Print All – opens a print-friendly view of all channels.
Channels Area

Each channel represents one instrument part (like a staff):

Channel header
- Title: Channel 1, Channel 2, ...
- Instrument selection (drop-down)
- Mute button
- Delete button
Volume slider (0–100)
DV Text Area (multiline)
Here you write DV notation, e.g.:

| Do4Q , Re4Q , Mi4Q , Fa4Q |

| Sol4Q , La4Q , Si4Q , Do5Q ||
Channel buttons
- Check Channel ✔ – validate DV text.
- Play Channel ▶ – play only this channel.
- Stop Channel ⏹
- Export Channel (Audio) 💾 – export this channel as MP3 (or WAV fallback).
- Export Channel (MIDI) 🎼
- Print Channel (PDF) – open this channel in a print-ready window.
Status lines
- Error line (red)
- OK line (green)

4. DV Language Basics in DVLCO

4.1 Boxes and Time

Music is written as boxes separated by vertical bars:

| ... | ... | ... ||

Each box contains notes/rests that must exactly fill its time.
The global setting beatsPerBox defines how big a box is.
- Example: beatsPerBox = 4 → each box is 4 quarter-note beats.
Internally, one quarter note (Q) is 24 ticks, so:
- Box capacity in ticks = beatsPerBox × 24.

If a box doesn’t add up to the correct number of ticks, you get an error like:

Box 2 has 60 ticks, needs 96.

The || at the end is just an end marker (visually like a double barline); it doesn’t add time.

4.2 DV Note Names and Octaves

Canonical DV note names:

Do, Re, Mi, Fa, Sol, La, Si

Each note is written as:

Name Octave Duration

Examples:

Do4Q – Do, octave 4, quarter note.
Sol5H – Sol, octave 5, half note.
La3E – La, octave 3, eighth note.

Octave is always a number (integer), e.g., 3, 4, 5.

Internally, DVLCO converts DV names to semitones (relative to C) and then to frequency:

Do → 0
Re → 2
Mi → 4
Fa → 5
Sol → 7
La → 9
Si → 11

Then it maps to MIDI starting around middle C and calculates the frequency.

4.3 Multi-Language Note Names

DVLCO supports many aliases for the seven notes. For example, all of these map to Do:

Do, do, DO
Chinese: 哆
Korean: 도
Japanese: ド
Russian: До, до
Hindi: सा
Thai: โด
Vietnamese: Đô, đô
Accent variants: Dó, dó

Similarly for Re, Mi, Fa, Sol, La, Si, with aliases in:

English, Chinese, Korean, Japanese, Russian, Hindi, Thai, Vietnamese, etc.
Also some accented versions for Portuguese/French/Spanish (e.g., Ré, Mi, Fá, Lá, Sí).

So for example, all of these are valid and represent the same pitch pattern:

| Do4Q , Ré4Q , Mi4Q , Фа4Q |

Internally they normalize to Do / Re / Mi / Fa / Sol / La / Si.

4.4 Accidentals: Sharps and Flats

Accidentals can be written in two ways:

Sharp: # or ♯
Flat: b or ♭

Examples:

Do#4Q and Do♯4Q are the same.
Reb4Q and Re♭4Q are the same.

Internally, they are converted to # and b and applied as semitone offsets on top of DV names.

4.5 Western Note Letters (Current Behavior)

In addition to DV names, DVLCO now understands Western letter notes of the form:

C4Q, D4Q, E4Q, F4Q, G4Q, A4Q, B4Q

These are internally mapped to the DV scale:

C → Do

D → Re

E → Mi

F → Fa

G → Sol

A → La

B → Si

So:

C4Q = Do4Q

D4Q = Re4Q

E4Q = Mi4Q

F4Q = Fa4Q

G4Q = Sol4Q

A4Q = La4Q

B4Q = Si4Q

Accidentals work the same way:

C#4Q / C♯4Q

Db4Q / D♭4Q

are interpreted as sharp/flat steps relative to this mapping.

Western letters are also used as chord roots (C, Cm, Cdim, C7, Csus2, etc.) and inside `+` groups (e.g., `C+E+GQ`). In all those contexts, the pitches stay consistent with the DV internal system.

5. Durations, Dots, and Tuplets

5.1 Basic Duration Symbols

The duration symbol is usually the last letter in the token:

W – whole note (1/1)
H – half note (1/2)
Q – quarter note (1/4)
E – eighth note (1/8)
S – sixteenth note (1/16)
T – thirty-second note (1/32)

Internally they are mapped to ticks with quarter = 24:

W = 96
H = 48
Q = 24
E = 12
S = 6
T = 3

You can also write them as fractions in parentheses:

Do4(1/4) = Do4Q
Re4(1/8) = Re4E

5.2 Dotted Notes

Add * for dotted durations:

Do4Q* – dotted quarter → 1.5 × Q
RestE* – dotted eighth rest, etc.

The engine:

Finds the base duration (e.g., Q = 24 ticks).
Adds half: 24 + 12 = 36 ticks.

Dotted T (1/32) is intentionally not supported in this demo to avoid very messy timings.

5.3 Tuplets / Triplets: `[i/n]`

Tuplet syntax is:

Note[ i/n ]Duration

For example:

Triplet inside a quarter: Do4[1/3]Q
→ 1/3 of a quarter → 8 ticks (since Q = 24).
Second note of the same triplet: Re4[1/3]Q
Third: Mi4[1/3]Q

The [i/n] notation tells the engine:

n – how many equal parts divide the base duration.
i – the index (1…n), used for display/logic; all parts use the same duration.

Order of operations:

Base duration (e.g., Q).
Apply dot if * is present (1.5×).
Divide by n from [i/n].

Again, this is demo-level math, but it is accurate for standard triplets with 24 ticks per quarter.

6. Rests and Mutes

There are several ways to write rests:

6.1 Partial Rests With Duration

The long forms:

RestQ, Rest(1/4)
RestE, Rest(1/8)
MuteH, Mute(1/2)
0Q, 0(1/4)

And short forms:

RQ, RH, RE, RS, RT
MQ, ME, MS, etc.
R(1/4), M(1/8), etc.

All of these mean “silent for this duration”. Dotted and [i/n] tuplet tags also work, e.g.:

RestQ*
RQ[1/3]

6.2 Full-Box Mute

You can mute an entire box with just:

| R |

| M |

| Rest |

| Mute |

| 0 |

| MW |

Each of these fills the entire box duration (equal to beatsPerBox × Q).

7. Fingering and Bow Direction

DVLCO is designed to ignore fingering numbers and letters for now, to keep the DV text compatible with later, more advanced articulation logic.

The parser:

Strips fingering patterns at the beginning of the note core.
Keeps bow direction markers (>, <, ^, -) so you can later use them for articulations.

Examples:

7.1 Fingering Before Note

These are all interpreted as the same note:

3>Fa4E
3Fa4E
2iDo4Q
3iSol4Q (guitar)

The digits and simple fingering letters (3, 3i, etc.) at the start are ignored, and the parser keeps:

Bow markers (>, <, ^, -)
The actual DV core (Do, Re, Mi, Fa, Sol, La, Si + octave + duration)

So:

3>Fa4E → bow > + Fa4E
3Fa4E → Fa4E
3iDo4Q → Do4Q
3iSol4Q → Sol4Q

7.2 Bow Markers Alone

These are meaningful and kept:

>Fa4E – down-bow
<Fa4E – up-bow
^Fa4E – accented
-Fa4E – “same bow” / tie feel

At the moment, bow markers don’t change the audio, but the code preserves them internally so in a future version the strings instruments (violin, viola, cello, etc.) can use them for direction-based phrasing.

7.3 Examples

All of these are valid:

V| >Sol4Q , <La4Q , >Si4Q |

V| <Do5Q , >Re5Q , <Mi5Q ||

FingerNoteDuration:

2>Fa4E ; 1<Mi4E ; 0>Do4E |

3<La4E ; 2>La4E ; 0<Sol4E ||

They will play with the correct pitches and durations; bow and fingering are metadata for future use.

8. Slides

Slides are written with -S- between two notes:

Do4E-S-Mi4E

DVLCO treats this as two events in sequence:

Play Do4 for an eighth.
Then Mi4 for an eighth.

Total ticks = sum of both durations; both behave like normal notes, just linked together in the parser as a “slide” structure.

In future, slide events can be rendered as continuous pitch glides depending on instrument; in this demo they are consecutive notes.

9. Groups, Chords, and Polyphony

9.1 “+” Groups: Play Simultaneously

A token with + means notes in a group, sounding at the same time:

Do4+Mi4+Sol4Q

This is a chord (triad) written with explicit pitches. Duration is taken from the group (here Q).

Rules:

All elements in the group must be either pitched notes or drums, but not mixed together.
If you mix drums and notes in the same group, the parser throws an error.

Examples:

Do4+Mi4+Sol4Q – DV triad.
C+E+GQ – Western letters triad (mapped around middle C).
Hh+KQ – two drum sounds together (if allowed by instrument).

9.2 Western Chord Symbols

A Western chord symbol token looks like:

C Q

Cm Q

G#Q

GmQ

General pattern:

Letter: A–G
Optional accidental: # or b
Optional m for minor.
Then duration.

Examples:

CQ – C major triad (C–E–G).
CmQ – C minor triad (C–Eb–G).
G#Q – G# major.
GmQ – G minor.

Current demo supports:

Major triads – e.g. C, D, E♭, F#, etc.
Minor triads – with m.

It does not yet implement:

Diminished (dim, °)
Half-diminished (ø)
Seventh chords (7, maj7, m7, etc.)
Suspended (sus2, sus4)
Add chords (add9, etc.)

These extensions are natural and can be added later by extending the chord-interval logic. For now, if you need more complex chords, you can always spell them manually with + groups:

CdimQ → (future: maybe C–Eb–Gb)

For now: write Eb4+Gb4+C5Q etc.

10. Drums and Cymbals

Drums use a small DV “code” mapped to frequencies and MIDI drum notes:

10.1 Drum Codes

K – Kick drum
S – Snare
T1 – High tom
T2 – Mid tom
T3 – Low tom
Rm – Rimshot
Cl – Clap
Hh – Hi-hat closed
Ho – Hi-hat open
Cr – Crash
Tr – Triangle / bell

Each is written with a duration symbol, e.g.:

KQ ; S(1/8) ; HhE ; CrQ

The code part (K, S, etc.) selects the drum instrument.
Duration works the same as notes (Q, E, etc.).

Internally:

Some drums are rendered with Tone.MembraneSynth (kick, snare, toms).
Cymbals/metallic sounds use Tone.MetalSynth.

In MIDI export:

Drums are mapped to standard General MIDI drum notes on channel 10 (index 9).

11. Repeats and Form

DVLCO supports a basic repeat syntax:

|: ... :|

For example:

|: Do4Q , Re4Q , Mi4Q , Fa4Q :|

| Sol4H , Do5H ||

Internally, the repeat section is duplicated, so:

|: A :|

is expanded to:

| A | A |

You can also chain repeat blocks like:

|: A :|: B :|

The parser normalizes this to something like:

| A | A | B | B |

If a line ends with ||, it is treated as an end marker and stripped for timing.

12. Per-Channel Instruments

Each channel has an instrument drop-down with entries like:

Keyboard (Default) – neutral melodic synth (DV melodic lines, chords, etc.).
Piano
Guitar
Harp
Strings / Violin / Viola / Cello / Contrabass
Winds – Flute, Oboe, Clarinet, Bassoon
Brass – Trumpet, Horn, Trombone, Tuba
Timpani
Drum
Cymbal
Triangle

Under the hood:

Most melodic instruments use Tone.PolySynth(Tone.Synth, …) with different oscillator types and envelopes (to approximate piano, strings, winds, etc.).
Drums/cymbals use MembraneSynth and MetalSynth.

The Keyboard / default instrument is designed to be a safe, neutral voice suitable for any DV melody.

13. Piano and Two-Hand Writing (Concept)

The goal for piano is:

A two-hand piano mode, where you can write right hand and left hand separately (like a grand staff) and have them played together.

Conceptually:

When you choose “Piano (Two Hands)” or create a dedicated pair:
- One channel is labeled Right Hand.
- Another channel is labeled Left Hand.
- Both use a piano-like synth and are played together with Play All.

In this demo:

You already can simulate this by creating two channels:
- Channel 1: Piano – right hand DV text.
- Channel 2: Piano – left hand DV text.
Mute/unmute as needed; Play All plays them together.

The two-hand “special mode” (auto-creation, auto-labelling) is an intended UX improvement, not yet a fully fixed standard. The manual here describes the intention and behavior so the DV format doesn’t have to change later.

14. Channels, Orchestra Playback, and Mute

Each channel has:

Instrument and volume.
DV text.
Local play, stop, export, print.

Global operations:

Play All:
- Parses each non-muted channel.
- If any channel has errors, it shows them and stops.
- Plays all schedules in parallel using separate synth chains.
Stop All:
- Stops the global playback flag.
- Each channel’s isPlaying flag is cleared.

You can use Mute on a channel to temporarily exclude it from Play All and from mix export, without deleting its text.

15. Export: Audio (MP3 / WAV)

15.1 How Export Works Technically

For the full mix:

DVLCO parses DV text in each non-muted channel.
It builds a schedule of events (notes, drums, rests) with exact durations and absolute times.
It uses Tone.Offline to render all channels into a single AudioBuffer.
It encodes the buffer either as:
- MP3, if lamejs is available.
- WAV, as a fallback.

For per-channel export, it does the same but only for that channel.

15.2 Why It Usually Exports MP3

The default export logic is:

let blob = audioBufferToMp3(buffer);

let filename = “... .mp3”;

if (!blob) {

blob = audioBufferToWav(buffer);

filename = “... .wav”;

}

So behavior is:

If lamejs is loaded → you get an MP3.
If not → audioBufferToMp3 returns null and it falls back to WAV.

That is why, in your tests, you mostly saw MP3 files.

If you prefer always WAV, you can change both export functions to call only audioBufferToWav and set filenames to .wav. The manual can mention this as a configuration choice.

16. Export: MIDI

DVLCO can export standard MIDI files:

Per channel – Channel X as dvlco_channelX.mid.
Full mix – all channels in one track as dvlco_full_mix.mid.

16.1 How MIDI Is Built

DV events are converted to a list of logical notes:
- Each note has:
  - startTick
  - endTick
  - midi note number
  - velocity
  - channel (0–15; 9 reserved for drums)
MIDI events:
- At startTick → Note On
- At endTick → Note Off
Track is created:
- Header: format 0, 1 track.
- PPQ (ticks per quarter) equals the DV quarter-tick constant (DURATION_TICKS.Q, usually 24).
- A tempo meta event sets microseconds per quarter from tempoBpm.
- Optional track name meta event.
Notes are sorted by time; if Note On and Note Off share a tick, Note Off is placed first, to avoid stuck notes.

16.2 Channels

Melodic notes: assigned to MIDI channels 0–15 except 9.
Drums: assigned to channel 9 (standard GM drums).

So DAWs and notation software should interpret it correctly.

17. Printing to PDF

Two options:

Print Channel
- Opens a new window with:
  - Title: “DVLCO – Channel X”
  - Instrument name
  - The channel’s DV text in <pre> formatting.
- You can use the browser’s Print → “Save as PDF”.
Print All
- Opens a single window containing all channels, one after another, each in a <section> with headings.
- Good for printing a full DV “score” of your piece.

This uses simple HTML + CSS, so it depends on your browser’s PDF/print support.

18. Validation and Error Messages

The Check Channel and Check All buttons run parseDvText over your DV notation and collect:

Parsing errors (unknown notes, invalid durations, mixed drum/note group, etc.).
Timing errors (total ticks in a box not equal to the box capacity).

Common messages:

DV text is empty.
No boxes ‘|’ found.
Box N has X ticks, needs Y.
Unknown DV note name “...”.
Mixed drums and notes not allowed in a single ‘+’ group. Use separate channels.
Invalid duration in “...”.
etc.

If a channel has errors, it shows them in the red status line and refuses to play or export until you fix the DV.

Here’s another version – same ideas, but a bit tighter, simpler, and more “manual style.”
You can paste this as one block in the blog.

Temporary “Fake Sustain” for Two Voices on One Staff (Demo v1)

In many classical and romantic pieces, a single staff carries two voices:

One voice holds a long note (pedal / cantus / sustained tone),
Another voice plays shorter notes above or below it.

In DVLCO – DV Language Composer Orchestra (Demo v1), the engine cannot yet let one note truly sustain independently inside the same box while another voice continues.

To still write real classical textures in DV Language, Demo v1 supports a temporary “fake sustain” trick.

Core idea

Whenever you write a + group like:

Do3W + Mi4Q

in Demo v1:

The duration before + (W in Do3W) is used for notation only
→ DV score / print treats this pitch as a long note.
The actual playback time follows the group duration (the “outer” duration – here Q on Mi4Q)
→ the group sounds like a quarter-note chord at that beat.

So you can write a sustained voice + moving voice correctly in DV,
even though the audio uses a simplified sustain.

Below are the main scenarios you need, with clear DV examples.

1. Pedal note with moving line (4/4, both start together)

Musical idea (single staff):

Time signature: 4/4
Lower voice: Mi₃ is a whole-note pedal (rings through the bar).
Upper voice: four quarter notes, for example Mi₄ – Fa₄ – Sol₄ – Mi₄.

If you wrote it “literally” in words:

| Mi3W ; Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q ||

this is not valid in DVLCO, because Mi3W alone fills the whole 4/4 box.

DV Language with fake sustain:

| Mi3W + Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q ||

How to read it:

Mi3W → Mi₃ is a whole-note pedal for the bar (notation meaning).
Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q → the moving voice in quarter notes.

What Demo v1 does:

Keeps W on Mi3W for DV score / print,
Uses the group duration Q for timing → Mi3W + Mi4Q sounds as a quarter-note chord on beat 1,
Then beats 2–4 = Fa4Q ; Sol4Q ; Mi4Q.

So you get:

Notation: one long bass + four quarter notes above (classical look),
Timing: 4×Q = correct 4/4 box.

2. Long top note with inner motion (both start together)

Now the sustained voice is at the top, with shorter notes underneath.

Musical idea (single staff):

Time signature: 4/4
Upper voice: Sol₅ as a dotted half note,
Inner voice: quarter notes Mi₅ – Fa₅ – Mi₅ – Sol₅.

Conceptually:

| Sol5H* ; Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q ||

Again, Sol5H* alone would overfill the bar for the engine.

DV Language with fake sustain:

| Sol5H* + Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q ||

How to read it:

Sol5H* → sustained top Sol₅ (dotted half-note in notation),
Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q → inner motion as quarter notes.

What Demo v1 does:

Stores H* on Sol5H* for notation,
Uses Q for timing → Sol5H* + Mi5Q sounds as a quarter chord at beat 1,
Remaining 3 beats: Fa5Q ; Mi5Q ; Sol5Q.

Again:

Notation: long top voice + inner motion, like real scores,
Audio: simplified sustain but clear texture.

3. Bass belongs to the bar, upper line starts later (not same-time start)

Sometimes you want:

“Mi₃ is a whole-note pedal in notation,
but the moving notes only start from beat 2.”

Musical idea in words:

| Mi3W ; Fa4Q ; Sol4Q ; Mi4Q ||

This cannot be played literally, because Mi3W already uses the full box.

DV Language with fake sustain (using a timing helper):

| Mi3W + Mi3Q ; Fa4Q ; Sol4Q ; Mi4Q ||

How to read it:

Mi3W → notation: Mi₃ is a whole-note structural bass.
Mi3Q → gives the first group its effective quarter duration (beat 1).
Fa4Q ; Sol4Q ; Mi4Q → beats 2–4.

Playback:

Mi3W + Mi3Q is a quarter on beat 1,
Then Fa4Q ; Sol4Q ; Mi4Q fill beats 2–4,
Total = 4×Q → valid 4/4 box.

Musically, you still think: “Mi₃ belongs to the whole bar,”
even though in sound it is re-articulated only at beat 1.

4. Re-striking the same sustained note later in the bar

You can also combine fake sustain with re-strikes of the same note.

Example idea:

Mi₃ is the bass of the bar,
Beat 1: Mi₃ + Mi₄,
Beat 3: Mi₃ + Sol₄.

One DV solution:

| Mi3W + Mi4Q ; Fa4Q ; Mi3Q + Sol4Q ; Mi4Q ||

Reading:

Mi3W → notation: Mi₃ is the bar-long bass,
Mi3W + Mi4Q → beat 1,
Fa4Q → beat 2,
Mi3Q + Sol4Q → beat 3 (Mi₃ re-struck with Sol₄),
Mi4Q → beat 4.

All durations are quarters → timing stays clean, but the DV text still shows the structural whole-note bass plus local re-strikes.

Same time vs different time (rule of thumb)

With this system:

Same time (chords / overlaps) → use +
- e.g. Mi3W + Mi4Q, Mi3Q + Sol4Q
Different times in the same box → separate with ;
- e.g. … ; Fa4Q ; Sol4Q ; Mi4Q

The fake sustain itself is only this:

A long “notation duration” (W, H, H*, …) before +,
A shorter “timing duration” (Q, E, …) after +,
So the bar’s total timing works, but the DV text still says: “this note is long.”

Practical checklist for composers (Demo v1 only)

When you need two voices on a single staff in one DV box:

Put the true musical length (what you want in the score) before +
- e.g. Mi3W, Do3W, Sol5H*.
Put the effective beat length (what must fit the bar) after +
- e.g. Mi4Q, Mi3Q, Mi5Q.
Make sure the sum of all group durations in the box equals the box capacity
- e.g. Q + Q + Q + Q in 4/4.

Typical valid patterns in Demo v1:

| Mi3W + Mi4Q ; Fa4Q ; Sol4Q ; Mi4Q ||
| Sol5H* + Mi5Q ; Fa5Q ; Mi5Q ; Sol5Q ||
| Mi3W + Mi3Q ; Fa4Q ; Sol4Q ; Mi4Q ||
| Mi3W + Mi4Q ; Fa4Q ; Mi3Q + Sol4Q ; Mi4Q ||

🛠 Note for readers (Demo v1)

The duration before + is notation-only (for DV reading, printing, future engraving).
The audio timing always follows the outer group duration.

In future versions, the goal is to:

Let long notes truly sustain independently inside one box,
Handle pedal / overlay inside the engine, without these manual tricks.

Until then, this fake sustain technique already shows that:

Classical two-voice textures on one staff
can be written, read, and printed in DV Language
even inside DVLCO – Demo v1.

19. Future Extensions (No Commitment, Just Direction)

Because this is a demo build, nothing here is a legal or commercial promise. But the architecture is designed to allow:

More chord types: dim, °, ø, 7, maj7, m7, sus2, sus4, add9, etc.
Full Western note support: C4Q etc. mapped consistently to DV (Do/Re/Mi…).
Musical degrees: DV degree-based notation (1, 2, 3, etc.) with key and scale awareness.
Bow-based expression: bow markers (>, <, ^, -) changing attack, volume, velocity curves for string instruments.
Articulation and dynamics: staccato, legato, accents, slurs, dynamic markings via extra tags.
More realistic instruments: sample-based or more advanced synths.
Piano two-hand mode: explicit UI support for paired channels representing right/left hand, maybe with automatic score splitting.
Direct DV-to-traditional-notation export via MusicXML or similar, using DV parsing as the core.

All of these can be added by extending the parser and scheduler without breaking the core DV text format you see here.

20. Closing Notes

DVLCO – DV Language Composer Orchestra is:

A playground for DV Language and orchestral thinking.
A demo, not a finished DAW.
A bridge between text, language, and sound.

Core ideas:

Write music in DV language (and supported translations).
Let a neutral engine interpret, validate, and play it.
Keep the format extensible so future versions (degrees, advanced chords, bow logic, better instruments) can grow without rewriting everything.

DVLCO – DV Language Composer Orchestra is a demo that is improved over time, with no final commitment, and that DV Language, the concept, and this orchestral tool are authored and led by Ronen Kolton Yehuda (MKR: Messiah King RKY) with the assistance of AI
DVLCO – DV Language Composer ORCHESTRA Demo v1
Study Music with DV Language — A New Way to Learn Music for All Ages & Levels
The DV Language Composer Family - Ronen Kolton Yehuda
The DV language: David’s Violin Language
The DV Language 📜 - Ronen Kolton Yehuda
The Integration of DV Language with AI: From Teaching Instruments to Creative Machines 🎶🤖
Music Theory with DV Language 📘 By Ronen Kolton Yehuda (MKR: Messiah King RKY) with the assistance of AI
Digital Music Instruments i developed - Messiah King RKY (Ronen Kolton Yehuda) — Digital and Hybrid Musical Instruments Catalogue

Authored by: Ronen Kolton Yehuda (MKR: Messiah King RKY)

Check out my blogs:

Substack: ronenkoltonyehuda.substack.com

Blogger: ronenkoltonyehuda.blogspot.com

Medium: medium.com/@ronenkoltonyehuda

Authored by: Ronen Kolton Yehuda (MKR: Messiah King RKY)

Check out my blogs:

Substack: ronenkoltonyehuda.substack.com

Blogger: ronenkoltonyehuda.blogspot.com

Medium: medium.com/@ronenkoltonyehuda

DVLCO – DV Language Composer Orchestra (Demo v1)

DVLCO – DV Language Composer Orchestra (Demo v1)

DVLCO — DV Language Composer Orchestra (Demo v1)

What is DVLCO?

Who is it for?

DV Language inside the Composer

1. Notes in multiple languages

2. Western letters mapped into DV world

3. Durations, dots, tuplets, triplets

4. Bars (“boxes”) and repeats

Instruments, channels, and the “orchestra”

Piano: two hands, one instrument

Drums & Cymbals

Rests, mutes, and full-bar silence

Chords: more than just single notes

Here’s a single, clean section you can paste into the blog manual, covering all fake-sustain scenarios (with your Mi bass example included) and explaining same-time vs not-same-time in this context.

“Fake Sustain” for Single-Staff Polyphony (Demo v1 Limitation)

Core rule – how the fake sustain behaves

Scenario 1 – Pedal tone + moving line (4/4, same-time start)

Scenario 2 – Sustained top note + inner motion (same-time start)

Scenario 3 – Bass fills the bar, upper voice starts later (not same-time start)

Scenario 4 – Sustained voice that reappears later (not same-time + re-strike)

Summary – Playing at the same time vs not at the same time

Practical rules for composers (Demo v1 only)

Slides, groups, and articulation markers

Slides

“+” groups (simultaneous events)

Bows and fingering (ignored for sound but accepted in text)

Export: MP3 (or WAV) and MIDI

Per-channel export

Full mix export

Printing and documentation

Settings: tempo, beats per box, validation

What this is – and what it is not (yet)

How to use it

Final note

1. Why I Built This

2. What DVLCO Actually Does

3. Writing Music as DV Text

Temporary workaround – “fake sustain” inside the box (demo limitation)

1. Long note + shorter notes in the same moment

2. Long bass + chords in the same box

4. Notes, Languages, Sharps, and Flats

Accidentals

Western Letters (C, D, E, …)

5. Rhythm, Dots, and Triplets

6. Rests, Mutes, and Full-Box Silence

7. Fingering and Bow Directions (Ignored in Sound, Preserved in Text)

8. Chords, Groups, and Harmony

8.1 “+” Groups (DV-style polyphony)

8.2 Western Chord Symbols

9. Drums and Cymbals

10. Instruments, Channels, and Piano

Piano, Two Hands

11. Export: Audio, MIDI, and Print

11.1 Audio Export (MP3 and WAV)

11.2 MIDI Export

11.3 Print / PDF

12. What Is Stable, What Is Experimental

13. Final Words

DVLCO – DV Language Composer Orchestra

First Edition Demo (v1)

1. Introduction – What Is DVLCO?

2. Technical Requirements

3. Layout Overview

4. DV Language Basics in DVLCO

4.1 Boxes and Time

4.2 DV Note Names and Octaves

4.3 Multi-Language Note Names

4.4 Accidentals: Sharps and Flats

5. Durations, Dots, and Tuplets

5.1 Basic Duration Symbols

5.2 Dotted Notes

5.3 Tuplets / Triplets: [i/n]

6. Rests and Mutes

6.1 Partial Rests With Duration

6.2 Full-Box Mute

7. Fingering and Bow Direction

7.1 Fingering Before Note

7.2 Bow Markers Alone

5.3 Tuplets / Triplets: `[i/n]`

Here’s another version – same ideas, but a bit tighter, simpler, and more “manual style.”
You can paste this as one block in the blog.