How to create realistic orchestral programming using Note Length & Velocity

For part IV of my Intro to Orchestral Sample Libraries series, we’ll be talking about how to create realistic orchestral programming using note length and velocity. These two parameters in particular, “velocity and note lengths,” don’t appear to be discussed as much in other orchestral programming lessons (at least I never hear it coming up much.) I’m not sure why as this is something I struggled with a lot when I first started. Before we dive in, let me tell you my story with velocity and note length and why I think they are so important:

When I was first starting out, and sending my music to publishers to be considered for TV and film music, I would often get feedback that went something like: “your writing is solid, but you need to update your orchestral samples.” I was getting rejected over and over, and the reason seemed to always be that my orchestral samples sucked! “What?” I thought, “I’m using top sample libraries from Spitfire, East West and LA Scoring strings, these are some of the best on the market.” First, I assumed I just didn’t know what I was doing (programming-wise). But, over time, I started to think that the publishers just didn’t like my music and was using my “bad samples” as an excuse to turn me away. This became very demotivating. Then one faithful day, one of the publishers replied saying,

I think you should check the note length on your short notes — they don’t seem *short enough* and it’s making your strings sound soft and loose when you need them to be sharp and tight.” Light bulb moment #1!

Around this same time, another publisher replied to another track submission saying,

your high notes are too harsh and piercing, check your note velocity.” Light bulb moment #2.


Your Orchestral Programming Doesn’t Sound Realistic, dude

So…….maybe, it’s not that my samples are bad, it IS my bad programming! This was great news. In addition to the fact that I knew that I hadn’t wasted money on all those samples, I now had some idea how to address my issues. Some of these concepts are very obvious and basic, but for me starting out, this was a huge breakthrough in my orchestral programming. I had been too sloppy before: I had assumed that a “short” articulation didn’t need to have a short note length, so I would let some notes be longer than others. As well, I had assumed that I should be pushing my louder musical moments higher by increasing the velocity on the note…sometimes, to the ear-piercing max! (What was I thinking?)


Choose the Right Articulation – first!

If you didn’t read my previous post on orchestral string articulations, I would strongly suggest you read that first as the first step in creating realistic orchestral programming is to make sure you’re always first choosing the right articulation for the job. Then, we use the various programming tools, like velocity and note length, to improve the overall sound. and make it sound more realistic. To segue into this topic, I’ll be using the example of needing a short, fast string sound with sharp attack. Imagine a piece of action music. There are often fast, repeating string lines (called “ostinatos”) that are used to create a sense of excitement, anticipation and action. As these notes are moving so fast, we need them to start quick and end quick (short.) Referring to my bad programming example above, this is where I messed up. First, I was often using staccato articulations. When you read my orchestral string articulation post, you’ll learn that while staccato is indeed short, it is not the shortest articulation — spiccato is the shortest. So, if we are after that quick, short string sound, we usually want to use spiccato articulations.

Wait, you mean it’s still not “short” enough?

So this is where things get tricky. Just for reference purposes, let first look at two MIDI notes that each trigger sounds:

realistic orchestral programming with Note Length and Velocity


Not all Samples are Created Equal

The first thing to be aware of is that different instruments and sounds react to MIDI notes in different ways. For this exercise, we will be focused on how most string instruments will respond. Be aware that you might purchase a library of some exotic instrument one day that follows its own use of the MIDI note lengths. When your DAW is playing back a piece of MIDI music and sees a MIDI note, like the two in the screenshot above, it will immediately start playing the sound that is assigned to that MIDI channel. The MIDI knows nothing about the sound (in this case a sample), or how it’s been delivered by the creators of the sample library. Think of it like pressing play on a tape recorder and then pressing stop when the note length ends (if you can remember what those tape recorder things are!) Referencing the screenshot above, if you are wanting to play a longer, sustained note that plays over a period of time, you would want to use a longer MIDI note like the one on the bottom. If you used a short note, the long sustained sample would start playing, but would stop making sound as soon as the MIDI note ended.

This seems straight forward, right? If you want a long note to play, then you make sure to use long MIDI notes that last as long as your note. In the case of the action style referenced above, where I really needed the notes to be quick with a sharp attack, I had forgot exactly what I just described above: The sample will play until the MIDI note is gone. I assumed that a “short” articulation, like staccato, would just play a quick note and be done. While it IS doing just that, the fact is, the full sound of the instrument hitting the strings can last longer than we want. As well, it can include the sound of the room (reverb), which might not seem like much, but, it can give the impression of a longer note when played fast.


Give it a Nudge

And, depending on the sample library, there could even be a split second of sound or space right before the main attack of the string. For example, if you imagine a string player pulling their bow back and striking it across their violin, there will be a brief run-up as the bow crosses the strings. This has the effect of making the full attack of the string hit just a split second after the MIDI note is triggered and not on the beat. If the music is going quite fast, as in the action music I was doing, these samples can start to blur together, as each note could be hitting their “attack” sound after the down beat and then ringing out a tad too long. The results can be not enough clarity between notes. To fix this, I first made sure I was using the shortest articulation,  spiccato. Then I went in and nudged each note ahead of the actual beat. This would have the effect of making the string “hit” hard on on the beat as the brief space before would now kick-off earlier. Once I had each note moved over and sounding in-time with the music (this takes awhile to tweak), I then shortened each MIDI note to make sure only the main hit of each attack was being played. (Must make sure it sounds natural of course — we don’t’ want to just cut the notes off either!) So, for a quicker-pace run of music, it might look something like the screenshot below. Look closely to find the gray beat marker lines. This is where the rest of the instruments are “hitting” their downbeats. You’ll see that I’m starting each string note just slightly before each of those lines so that the attack that comes after it will then be in-time with the rest of the music and sound sharper.


realistic orchestral programming with Note Length and Velocity


Nudging the notes and cropping their length like this is something you’ll need to experiment with for each sample library. This is because different companies use different amounts of this “pre space” based on how their players perform and how ultimately process their samples. And, as I mentioned above, you want it to sound natural and realistic of course!  This is just as important for long articulations. Especially for legato where there is usually a longer period of time from the start of the MIDI note to when the full attack of the performance is heard. So, a legato transition might look more like the screenshot below. Note how far ahead of the beat that the MIDI note is starting. This give time for the bow to move into its full attack. Also, you’ll see that the 2 notes are overlapped. This is because with legato, we need to capture the transition from one note to the next. This tells the sample library scripting to “play” that transition from the first note to the second.


realistic orchestral programming with Note Length and Velocity


Before we move on, just a reminder that note length is also important for long notes where you want to make extra sure that the note is indeed long enough to play the entire string line.



In Orchestral Programming, Velocity goes to 127!

If you’re not familiar with what the numbers 0 to 127 mean in the world of MIDI, I’ll quickly describe it here as being the range of a single note’s intensity. In other words: how hard the player plays the note. Each level of player intensity is given a number from 0 to 127. In the case of a drum, a velocity of 20 would be a soft hit on the drum, while 120 would be a loud, forceful BANG on the that same drum. Sample libraries go through and sample lots and lots of each intensity hit, in order to give us a different sound for each velocity number we select. I’m not sure if they literally record 128 different hits (0 to 127), but I’m pretty sure they usually get close to that! This is one of the distinctions that can make a sample library sound more realistic over another.  It’s also important to know that not all sample libraries are the same. A velocity of 50 for one instrument made by company A, might sound more like the velocity of 70 for the same instrument created by company B. I’ve also found that percussion can be pushed much harder than most other instruments. It’s not uncommon to see most of a percussion sequence maxing out at 120-127. Meanwhile, if you try that on high strings, you will have someone tell you that “your strings are piercing our eardrums”. Even for my most loud and intense music, I rarely push my strings over 75/80 — I’ve found the higher velocities are just too harsh for most of my music. So, the lesson here is: You need to audition velocity for each and every instrument you use and not assume that louder, more powerful needs to mean 127 velocity.

Most DAWs use color or some other visual indicator to display the velocity of a given note. Below is a screenshot from Logic Pro. The softer velocities start as green, and move up to red as the most intense.   You can imagine a drum roll that is building up to a big chorus might employ this exact technique. For me, I find that the lighter oranges are about as intense as I push most of my orchestral samples — the darker oranges and red (high velocity) seem to always sound too harsh, for me. As I mentioned above, even when I want the strings to sound loud and forceful, I find myself keeping them at these lower velocities in order to create the realistic orchestral programming I’m after. Meanwhile, I find that I need to push my drum and percussion samples up into the higher velocities to get the sound I’m after. Of course, this is all dependent on your style of music and the sample library you are working with.


realistic orchestral programming with Note Length and Velocity




I hope this was helpful in learning some techniques to create realistic orchestral programming. Much of it is common sense. If you want a note to play longer, then make sure it is (physically) longer! And for a short note? Hmmmmm….yes, make it short! However, within these basic concepts is a lot of nuance and detail. It took me time to really understand how, exactly, the sample libraries were responding to the MIDI notes I programmed. Many times, especially when you want to recreate a realistic orchestral performance, you’ll need to experiment, tweak and be critical of the note length and velocity setting for every single note in your piece. It can take time to get just right, but in the end, it’s worth it when your orchestra sounds (more) realistic.

Don’t forget to check out the previous post orchestral string articulations as well as the rest of this series on Intro to Sample Libraries for more lessons on creating realistic orchestral programming!


Watch the video!


Watch the Youtube Video of this lesson!

Leave a Reply

Your email address will not be published. Required fields are marked *