Streamlined sample-based instrument platform

Floe lets you find, perform and transform sounds from sample libraries — from realistic instruments to synthesised tones. Handmade with care, Floe is no-hassle, open-source and always free.

Download Now

Find the right sound quickly

Floe’s intuitive browsing system works across all your Floe sample libraries, bringing together instruments and presets through categories, tags, and powerful search. The sound you need is always a few clicks away.

Transform sounds

With three distinct layers, Floe lets you blend instruments across different libraries. Transform sounds with loop and crossfade controls that bridge the gap between multisampling and synthesis. Process your sounds further with a rack of 10 built-in effects.

Focus on making music

Available as a plugin for your DAW (CLAP, VST3, and AU) on Windows and macOS. No accounts, no subscriptions, no interruptions — just musical creation. Openness is at the core of Floe and its libraries.

Expanding library selection

The list of libraries available for Floe is growing. And they’re installable in a few clicks. If you’re a developer, you can make your own libraries for Floe and request adding them to the list.

Handmade software

Handmade and detail-focused, Floe is a professional-grade tool available to everyone. It’s made by Sam Windell, who also runs a sample library development company: FrozenPlain.

Anyone can make libraries for Floe and contribute to the open source project. By consolidating our efforts into improving this engine, we improve the capabilities of all of its libraries for everyone.

Built on a solid foundation

Built on the architecture of FrozenPlain’s Mirage, used in professional productions for years. Floe is the next evolution, designed with careful attention to reliability and performance. We’re committed to further expanding its capabilities while maintaining backwards compatibility.

About this website

This website contains everything you need to know about Floe. It’s presented in a book-like format, with chapters in the sidebar.

If you’re viewing this online, you might find the search feature useful: open it by clicking the magnifying glass icon at the top-left of the page. Additionally, there is a print icon at the top-right for either printing this book, or saving it to a PDF.

Requirements

Windows

On Windows, Floe is available in the CLAP and VST3 formats. We recommend using the CLAP version where possible. Requirements:

• Windows 10 or later
• 64-bit computer
• x86-64 processor with SSE2 support (almost all processors in a Windows PC since ~2006 have this)
• 64-bit CLAP or VST3 host

macOS

On macOS, Floe is available in the CLAP, VST3 and AU (v2) formats. We recommend using the CLAP version where possible. Requirements:

• macOS 11 (Big Sur) or later
• Apple Silicon or Intel (Floe is a universal binary)
• CLAP, AU (v2) or VST3 host

Plugin Hosts (DAWs)

Here are some examples of plugin hosts that can run Floe. There are many more than this.

• CLAP hosts on Windows & macOS: Reaper, Bitwig, FL Studio (2024 or newer) and Studio One Pro (v7 or newer).
• VST3 hosts on Windows & macOS: Cubase, Ableton Live, Reason, and more.
• AU hosts on macOS include: Logic Pro, GarageBand, and more.

Not supported

Just for clarity: there’s no Linux, no ‘standalone’ application and no AAX (Pro Tools) support. We hope to expand Floe’s compatibility in the future.

Download & Install Floe

There’s two ways to install Floe: use the installer, or manually move files.

Either way, Floe is backwards-compatible¹. This means that you can replace an old version of Floe with a new version and everything will work.

Please check the requirements before downloading.

Additional information:

• Floe is totally free, there’s no signup or account needed; just download and install.
• Sample libraries and presets are installed separately via packages.
• The latest released version of Floe is v0.8.3-beta.

Installer

Floe Installer Windows: Download Floe-Installer-v0.8.3-beta-Windows.zip (32 MB)

Floe Installer macOS: Download Floe-Installer-v0.8.3-beta-macOS.zip (108 MB)

Download, unzip, and run the installer program. The installer will guide you through the installation process, including choosing the plugin formats you want to install.

Once the installation is complete you might need to restart your DAW in order for it to find the Floe plugins.

Manually Install

Floe Manual Install Windows: Download Floe-Manual-Install-v0.8.3-beta-Windows.zip (28 MB)

Floe Manual Install macOS: Download Floe-Manual-Install-v0.8.3-beta-macOS.zip (108 MB)

Normally you’ll want to use the installer, but there could be some cases where you’d prefer to install Floe manually. To allow for this, we provide a zip file that contains Floe’s plugin files. Extract it and move the files to your plugin folders.

Windows:

• CLAP: Move Floe.clap into C:\Program Files\Common Files\CLAP
• VST3: Move Floe.vst3 into C:\Program Files\Common Files\VST3

macOS:

• CLAP: Move Floe.clap into /Library/Audio/Plug-Ins/CLAP
• VST3: Move Floe.vst3 into /Library/Audio/Plug-Ins/VST3
• AU: Move Floe.component into /Library/Audio/Plug-Ins/Components

Download links can also be found on the Github releases page.

Uninstalling

Windows

On Windows, Floe can be uninstalled using the standard method for uninstalling software, via the ‘Add or Remove Programs’ control panel. See the Windows documentation here.

This uninstalls Floe, but not libraries or presets. Follow the instructions below to delete libraries and presets.

This uninstaller also supports uninstalling Mirage, the predecessor to Floe.

macOS

We don’t have an uninstaller program for macOS. But you can manually uninstall Floe by deleting its files.

Manual Uninstall

Delete libraries and presets

1. Open Floe
2. Click on the cog icon at the top.
3. Open the ‘Folders’ tab.
4. For each of the paths click the ‘open folder’ icon: . This will open the folder in your file manager.
5. Delete all files in the folder.

Repeat this for each folder in Floe preferences panel.

Delete Floe

Floe consists of plugin files, and a preferences file. The preferences file is normally tiny: around 1 Kb in size. Plugins files are normally around 15 MB in size.

Delete the following files if they exist:

macOS

• Preferences: /Users/Shared/Floe/Preferences/floe.ini
• CLAP: /Library/Audio/Plug-Ins/CLAP/Floe.clap
• VST3: /Library/Audio/Plug-Ins/VST3/Floe.vst3
• AU: /Library/Audio/Plug-Ins/Components/Floe.component

Windows

For Windows, use the uninstaller program described above. If you want to manually delete Floe, delete the following files:

• Preferences: C:\Users\Public\Floe\Preferences\floe.ini
• CLAP: C:\Program Files\Common Files\CLAP\Floe.clap
• VST3: C:\Program Files\Common Files\VST3\Floe.vst3

Delete Mirage

If you used to have Mirage installed then some additional files may be present. To uninstall Mirage, delete the following files. Some of these files may not exist.

macOS

• Preferences: /Library/Application Support/FrozenPlain/Mirage/Settings/mirage.json
• Preferences (alternate): /Users/<your-name>/Music/Audio Music Apps/Plug-In Settings/FrozenPlain/mirage.json
• Preferences (alternate): /Users/<your-name>/Library/Application Support/FrozenPlain/Mirage/Settings/mirage.json
• VST2: /Library/Audio/Plug-Ins/VST/Mirage.vst
• AU: /Library/Audio/Plug-Ins/Components/FrozenPlain Mirage.component

Windows

• Preferences: C:\ProgramData\Mirage\Settings\mirage.json
• Preferences (alternate): C:\Users\<your-name>\AppData\Local\FrozenPlain\Mirage\mirage.json
• VST2: C:\Program Files\VSTPlugins\mirage64.dll
• VST2 (alternate): C:\Program Files\Steinberg\VSTPlugins\mirage64.dll
• VST2 (alternate): C:\Program Files\Common Files\VST2\mirage64.dll
• VST2 (alternate): C:\Program Files\Common Files\Steinberg\VST2\mirage64.dll

Packages

Sample libraries and presets are typically put into ZIP files called Floe packages. This makes them convenient for downloading and installing.

Floe can easily extract and install these packages.

Additional Information

Packages are just normal ZIP files, but they contain subfolders in a particular structure that Floe knows how to handle.

Because they are just ZIP files, Floe is actually not required; you can unzip the package yourself and use the libraries for something unrelated to Floe if you wanted.

A package can contain any number of libraries and/or presets. Typically though, a package contains one library and a folder of factory presets for that library.

Just like the libraries and presets themselves, packages are portable - you can copy them to other computers or operating systems.

Installing Packages

Floe can install sample libraries and presets from ZIP files called Floe packages.

‘Install package’ button

Install Floe first, and open it in your DAW.

Next, don’t extract the ZIP package. Instead, use the ‘Install package’ button in the preferences panel and direct it to the ZIP file. It will extract the package into the correct folders. The library/presets will be available immediately, no need to restart Floe.

Here’s the full steps:

1. Open Floe.
2. Open the Preferences panel using the cog icon at the top.
3. Open the Packages tab.
4. Click the ‘Install package’ button and direct it to the package ZIP file.
5. Done. After installation, you may delete the ZIP file. No need to restart Floe.

Mirage Compatibility

If the package is a Mirage library you will also need to install the Mirage Compatibility package. Download and install it the same way as the main package. Download Mirage Compatibility Package.zip.

Floe handles the details

Floe handles the installation process intelligently. It will check existing installations across all known folders, check for conflicts and handle upgrades. It will even detect if you’ve modified a library and give you the option to keep your modified version. It will ask you about skipping or overwriting if it needs too. It will never duplicate libraries unnecessarily.

Manually installing

Alternatively, you can manually install libraries and presets by extracting the ZIP file into the correct folders.

1. Extract the package ZIP file.
2. Open Floe.
3. Open the Preferences panel using the gear icon at the top.
4. Open the Folders tab.
5. Here you can control which folders Floe looks for libraries and presets in. Copy/move the contents of this package’s Libraries into one of Floe’s library folders, and the same for Presets into one Floe’s presets folder.
6. Done. No need to restart Floe.

Available Packages

Floe can install libraries and presets from ZIP files called Floe packages.

Here are some available packages.

Music Box Suite Free - Free

Free multisampled music box from FrozenPlain.

Celtic Harp - Free (attribution required)

The background image is Harpe Celtique Telenn Gentañ - Alan Stivell - 04 by Jérémy Kergourlay, and is licensed under CC BY-SA 4.0.

We made a Floe-compatible version of Etherealwinds Harp 2: Community Edition by Versilian Studios which is licensed under a Creative Commons Attribution 4.0 International License. It’s a high-quality multisampled harp with velocity layers and round robins. Versilian Studios have a more advanced version of this harp available for purchase.

Xylophone - Free

The background image is Xylophone and percussion by CrashingWaves, licensed under CC BY 2.0.

This is a basic free multisampled xylophone from FreePats, converted into a Floe library.

Ocarina - Free

This is a basic free ocarina from FreePats, converted into a Floe library.

Antique IRs - Free

Give your presets a vintage sound using this library of impulse responses that simulate old audio equipment.

It’s a Floe port of NoiseCollector’s impulses response library; created with the use of public domain recordings of historical events. Vintage equipment like dicta-phones, old film reels, vintage vinyl, wax cylinders, and magnetic wire.

Impulses can be used to simulate war reports, old radio broadcasts, space missions, and other vintage sounds with a convolution reverb.

Mirage Compatibility - Free

Compatibility files for working the FrozenPlain Mirage libraries inside Floe.

For Mirage libraries to fully work inside Floe, the Mirage Compatibility library is needed. This library will normally be included alongside Mirage libraries, but it can also be installed separately.

Mirage Libraries

Floe fully supports all Mirage libraries: FrozenPlain shop.

Sample Libraries

Floe is an engine that requires Floe sample libraries to make sound. This page describes Floe’s sample library format and how to manage your libraries.

Related pages:

• Available libraries
• How to install libraries
• Develop your own libraries (programming required)

Floe also supports the legacy Mirage library format.

Custom open format

Floe sample libraries use a custom, open format consisting of a folder of audio files and a file in the Lua programming language called floe.lua.

Access to the audio files gives you the freedom to use a library’s sounds in other software too.

Openness is a key goal of Floe sample libraries.

There’s no proprietary file formats. There’s just FLAC, WAV and Lua. By using widely-used file formats we ensure the longevity of libraries.

Portable

Sample libraries are just normal folders. They don’t reference anything outside their folder, meaning they totally portable; you can move libraries to other locations, or even to other computers/operating systems due to their cross-platform nature.

View installed libraries

You can view your installed libraries by clicking the info button on Floe’s main window.

Library folders

Floe automatically scans for sample libraries in a set of folders. You can configure these folders in Floe’s preferences panel, which is opened by clicking the cog icon at the top of Floe’s window. Subfolders are scanned too.

The default library folder cannot be removed, but you can add and remove any other folders you like.

Moving and rearranging libraries

You may rearrange your libraries within your folders as you see fit. Floe will automatically detect changes and apply them. For example, you might want to create subfolders for different types of libraries, or to separate libraries from different developers.

You can also move your existing libraries to another location, such as an external drive.

To do this, you will need to move the libraries in File Explorer/Finder, and then add the new location in Floe’s preferences.

Here’s that process in more detail:

1. Create your new library folder at your desired location. For example, create “Floe Libraries” somewhere on your external drive.
2. Open the Preferences panel by clicking the cog icon at the top of Floe’s window.
3. Under ‘Folders’, click on the link button for the folder that you want to move libraries out of. A File Explorer/Finder window will open.
4. Use File Explorer/Finder to move the libraries to your desired new location (libraries are folders — typically with this naming pattern: ‘Developer - Library-name’).
5. Go back into Floe, and add the new location by clicking the ‘Add Folder’ button. Remember, Floe will find libraries inside subfolders as well as the top-level, so select the “Floe Libraries” folder (or whatever name you chose), instead of the individual library folders.

Presets

Floe can save its current state as a preset file, which can be loaded later. It’s the same file type regardless of what sample libraries you’re using; a .floe-preset file. When you load a preset, Floe will check that you have the required libraries installed, and if not, it will show an error.

Presets are portable - you can copy them to other computers or operating systems. You can rearrange them into folders and rename them as you like.

Preset browser

Floe features a browser for conveniently navigating and loading presets from your preset folders. Filter presets using the left-hand panel, and select presets from the right-hand panel. You can also search for presets using the search bar at the top.

Preset folders

Floe automatically scans for presets in a set of folders - including subfolders. This works in the exact same way as your library folders.

Presets are tiny files and so there’s typically no need to move then to an external hard-drive.

Layers

Floe is built around an architecture of three layers. These are displayed in three columns starting from the left of the main panel. Each layer is identical. Floe’s layers are the first things in the processing chain; each layer is processed in parallel, and then the three streams of audio are mixed together and fed through the effects rack, from top to bottom.

Instruments

Each layer can contain an instrument. The instrument is the sound generator. It’s like an oscillator in a traditional synthesizer. However, for Floe, instruments are sample-based. Sometimes an instrument is a realistic, complex multisampled real musical instrument, sometimes it’s a single looping sample. Floe also has a couple of basic synth waveforms designed for layering with other instruments.

To load an instrument, click the menu button at the top of the layer. Change it from ‘None’ to an instrument of your choice. You will be able to pick from any of the instruments that are available in the libraries that you have installed.

How an instrument works is defined in the library that it comes from. Most instrument allow for adding or customising sample loops.

Sound shaping

You can shape the sound of each layer in quite a few ways.

Effects

Floe has a selection of 10 effects that can be applied to the audio. These effects are applied to the mix of the three layers. The effects are shown in a list on the right-hand side of the main panel. You can change the ordering of the effects by dragging and dropping the effect names — either the name in the rack or the name next to the on/off switch.

MIDI

Map parameters to MIDI CC

All automatable parameters in Floe can be assigned to a MIDI CC. This allows you to control Floe from a MIDI controller for example.

To do this, right-click on the parameter you want to assign, and select ‘MIDI Learn’. Then move the control on your MIDI controller that you want to assign to that parameter. This will create a mapping between the parameter and the MIDI CC.

You can remove this mapping by right-clicking on the parameter and selecting ‘Remove MIDI Learn’.

This mapping is saved with your DAW project. But it’s not permanent. It only applies to the current instance of Floe in your DAW, and it won’t be the applied if you load a new instance of Floe.

Preset files do not save MIDI CC mappings. So you can load presets and your MIDI CC mappings will remain.

Make MIDI CC mapping more permanent

You can make the MIDI CC mapping more permanent by right clicking on a ‘MIDI learned’ parameter and selecting ‘Always set MIDI CC to this when Floe opens’. As the name suggests, when you open Floe, the MIDI CC mapping will be added.

Sustain Pedal

Floe can be controlled with a sustain pedal. A sustain pedal is a special kind of MIDI controller that sends MIDI CC-64 messages. These messages represent an on or off state.

When Floe receives a sustain pedal on message, all notes that are currently held will sustain until a corresponding sustain pedal off message is received. The notes will persist even if the notes are released from the keyboard. Only releasing the sustain pedal will trigger them to stop. This is a common behaviour for synths and samplers alike. It roughly simulates the behaviour of a real piano sustain pedal.

Sustain Pedal Retrigger Mode

Each layer in Floe has a switch that changes the behaviour when pressing the same note multiple times while the sustain pedal is held down. This parameter can be found in the MIDI tab of each layer and is called ‘CC64 Retrig’.

When ‘CC64 Retrig’ is turned off, and you are holding the sustain pedal down, nothing happens if you press the same key multiple times — the new up and down is ignored — the sound continues to sustain just as it did before.

However, when ‘CC64 Retrig’ is on, the note is retriggered (the sound ends and a new one starts); this behaviour tends to be the more intuitive option. Note that this switch is per-layer, not global. This allows for more powerful customisation of a preset.

Looping

One of the ways that Floe extends into the realm of sample-based synthesis is by offering some powerful looping features.

These looping features adapt to whichever instrument is loaded (the instrument being the sound generator that was loaded into a layer). The GUI makes it clear what the available looping options are.

Most instruments allow you to loop the sound in some way - even when the instrument is a multisampled instrument. However, sample library developers can choose to offer built-in loops, only allow certain modes or disable looping altogether.

There are 2 loop modes available in Floe: standard wrap-around looping, and ping-pong looping. In the standard mode, the sound will jump back to the start of the loop when it reaches the end. In ping-pong mode, the sound will alternate playing forwards and backwards through the loop. A crossfade can be applied to smooth the boundary - even in ping-pong mode.

As well as looping, you can control whether the sounds are reversed or have their start position offset.

Parameters

For reference, here is a list of all parameters in Floe.

Autosave

Floe reduces the chance of you losing your work by automatically saving its state frequently.

Autosaves are useful if either Floe or the DAW crashes unexpectedly — hopefully a very rare occurrence. But they’re also useful for other reasons such as accidentally removing a track, or changing parameters in a way you didn’t intend.

Every instance of Floe has an auto-generated name, for example: dawn-205. You can see this in the top panel of Floe’s window. This is useful because it helps identify which instance of Floe an autosave came from so that you can correctly restore it. Autosave files also contain the date and time they were created.

The autosave feature has reasonable default settings, but you can edit them in the Preferences panel too.

Autosaves are just preset files. You can load them as you would a preset file. Autosaves can be found here:

• Windows: C:\Users\Public\Floe\Autosaves
• macOS: /Users/Shared/Floe/Autosaves

Some additional things to note:

• The autosave system is efficient - it shouldn’t noticeably slow your computer down.
• Floe will automatically delete autosaves older than a given number of days.
• Floe will only keep a certain number of autosaves per instance. If the limit is reached, the oldest autosave will be deleted to make room for the new one.
• Autosaves are tiny files, typically around 2 Kb in size. Your computer won’t run out of space because of them.

In the future we’d like to add a friendly interface for browsing and restoring autosaves.

Attribution

At a glance

If a sample library requires attribution:

• Floe will show you the required attribution text.
• Copy-and-paste this text alongside wherever you share your music.
• You own your music (sell it, relicense it, etc.) - you just need to credit the creator of the sounds.

The above bullet points assume the license is the “Creative Commons Attribution 4.0 International” license — a very common attribution-required license.

About attribution-required licenses

A license tells you what you can and can’t do with a sample library. Most developers choose a license that allows you to use the sounds in your music without having to credit them.

However, some developers choose an attribution-required license such as the widely-used Creative Commons Attribution license (also known as “CC BY”).

This license allows you to use the sounds for free, even in commercial projects, as long as you credit the creator by including a bit of attribution text along with your music. For example, you might include the text in a caption on your website, in the album notes or in a credits roll (or any “reasonable manner”). The music that you create with sounds under this license is yours: you can sell it, stream it, relicense it or give it away; you are just required to credit the sound’s creator.

For some people, giving attribution is a deal-breaker. But here’s some reasons why it might not be so bad:

• Attributions can support the creators of sounds - providing them with recognition, traffic, and potential customers.
• Sharing where your sounds come from helps other musicians find great sounds too - increasing the quality of music everywhere.
• Attributions can look professional and show a high level of care in your work.

How Floe helps

Floe makes it dead-easy to comply with attribution requirements. When you load a sound from a library that requires attribution, Floe will show a small icon in the top of the window. Clicking this will show you the exact text that you can copy-and-paste wherever you need to. Floe tracks all attribution requirements across all instances of Floe, so you only need to do it once.

Example of the attribution GUI in Floe

Disclaimer

Whilst this page is based on careful research and understanding of the topic, it is not legal advice.

Error Reporting

Floe strives to be reliable for professional work. To help us achieve this we have various systems in place.

Error reports

If Floe detects that something has gone wrong, it will submit a totally anonymous error report to us. This report contains information about the error, the state of Floe leading up to the error, and information about the computer Floe is running on.

This enables us to get the key information to fix bugs quickly without having to get you to manually gather and send us information.

You can disable all online reporting in the Preferences panel if you wish. Floe is open source, so you can also inspect the code to see how this works.

Send feedback

Floe has a form that you can use to submit bug reports, feature requests, or general feedback. This is found by clicking on the ‘Send Feedback’ button in the three-dots menu at the top of Floe’s window.

Please use this to report any issues you encounter. We want to know about it and want to fix it.

Crash protection

Floe tries to never crash the host. If Floe detects that something has gone wrong, it will enter an unresponsive mode rather than crashing the host. It won’t produce any sound and it can’t be interacted with.

In this rare situation, make note of the instance name at the top of Floe’s window, such as ‘dawn-205’. Then, remove the plugin from your DAW and re-add it. You can then restore your work from an autosave with the instance name you just noted. Anonymous crash information will usually be reported to us automatically for us to address the issue.

Developing Libraries for Floe

This page explains how to develop sample libraries for Floe. Some basic programming knowledge is required.

Floe’s sample library format

Floe’s format is designed for configuring audio files into playable instruments. It does not add any audio-manipulation or custom GUIs. Floe has a ready-to-use GUI and lots of audio parameters. In the future we might add more advanced scripting/GUI creation features to the format. The format is designed to be extended whilst retaining backwards compatibility.

Floe’s sample library format currently supports the following features:

• Velocity layers
• Round-robin
• Crossfade layers
• Loop points with crossfade
• Convolution reverb IRs
• Velocity layer feathering
• Trigger samples on note-off

Why a new format?

No existing format met our requirements for Floe, which are:

• Libraries should be plain folders of audio files.
• Libraries should be portable across filesystems & operating systems.
• Libraries should be configured using a proper programming language to enable creating complex libraries in a maintainable way.
• The format should be extensible - allowing us to innovate in the field of sampling.
• The solution should easily integrate into Floe’s codebase.

Developer friendly

Floe’s format is designed to be developer-friendly. It plays well into the tooling and experience of people who are used to dealing with code:

• Works with version control: libraries are just folders of files, they’re portable across filesystems and operating systems.
• Hot reloading: Floe automatically reloads the library whenever you change a file: Lua, audio, or images. It creates a very fast feedback loop.
• Uses a full programming language: Lua is simple, powerful, and widely used. You can use variables, functions, loops, and conditionals to configure your library.
• Floe’s Lua API is simple and concise.

The structure

Let’s look at the structure of a Floe sample library:

📂FrozenPlain - Slow/
├── 📄slow.floe.lua
├── 📄Licence.pdf
├── 📄About Slow.html
├── 📁Samples/
│   ├── 📄synth_sustain_c4.flac
│   └── 📄synth_sustain_d4.flac
└── 📁Images/
    ├── 📄background.png
    └── 📄icon.png

There’s only one essential part of a Floe sample library: the floe.lua file. This file can have a custom name so long as it ends with .floe.lua - for example, woodwind-textures.floe.lua.

The rest of the structure are conventions that are recommended but not required:

• Licence: Sample libraries are recommended to have a file called Licence that describes the terms-of-use of the library. It can be any format: PDF, TXT, etc.
• About: A file that describes the library. Any file format. Information about a library is useful for when someone might not have Floe’s GUI available. Use this document to explain what the library contains, website links and any other information that might be useful. Floe’s packager tool can automatically generate this file.
• Library folder name: The folder containing the floe.lua file should be named: “Developer - Library Name”.
• Subfolders: Subfolders are up to the developer. We recommend ‘Samples’ for audio files and ‘Images’ for images. These can have any number of subfolders. Your floe.lua file can reference any file in these subfolders.

The floe.lua file

The floe.lua file is the most important part of a library. It’s a script that maps and configures the audio files into playable instruments, written in the Lua 5.4 programming language.

This file uses Floe’s Lua functions to create the library, create instruments, and add regions and impulse responses. It can reference any file in the library using relative paths.

Here’s a made-up example of a floe.lua file:

local library = floe.new_library({
    name = "Iron Vibrations",
    tagline = "Organic sounds from resonating metal objects",
    library_url = "https://example.com/iron-vibrations",
    description = "A collection of resonating metal objects sampled using a handheld stereo recorder.",
    author = "Found-sound Labs",
    author_url = "https://example.com",
    minor_version = 1,
    background_image_path = "Images/background.jpg",
    icon_image_path = "Images/icon.png",
})

local instrument = floe.new_instrument(library, {
    name = "Metal Fence Strike",
    folder = "Fences/Steel",
    description = "Tonal pluck metallic pluck made from striking a steel fence.",
    tags = { "found sounds", "tonal percussion", "metal", "keys", "cold", "ambient", "IDM", "cinematic" },
    waveform_audio_path = "Samples/file1.flac",
})

floe.add_region(instrument, {
    path = "Samples/One-shots/Resonating String.flac",
    root_key = 60,
    trigger_criteria = {
        trigger_event = "note-on",
        key_range = { 60, 64 },
        velocity_range = { 0, 100 },
        round_robin_index = 0,
        feather_overlapping_velocity_layers = false,
        auto_map_key_range_group = "group1",
    },
    loop = {
        builtin_loop = {
            start_frame = 24,
            end_frame = 6600,
            crossfade = 100,
            mode = "standard",
            lock_loop_points = false,
            lock_mode = false,
        },
        never_loop = false,
        always_loop = false,
    },
    timbre_layering = {
        layer_range = { 0, 50 },
    },
    audio_properties = {
        gain_db = -3,
    },
})

floe.set_attribution_requirement("Samples/bell.flac", {
    title = "Bell Strike",
    license_name = "CC-BY-4.0",
    license_url = "https://creativecommons.org/licenses/by/4.0/",
    attributed_to = "John Doe",
    attribution_url = "https://example.com",
})

floe.add_ir(library, {
    name = "Cathedral",
    path = "irs/cathedral.flac",
    folder = "Cathedrals",
    tags = { "acoustic", "cathedral" },
    description = "Sine sweep in St. Paul's Cathedral.",
})

return library

floe.new_library() must be called and returned it at the end of the script. All other features are optional. When Floe runs your Lua file, it will show you any errors that occur along with a line number and a description.

How to get started

For now, we’ll assume that you have a folder of audio samples and know what notes they correspond to.

1. Create a new folder in one of Floe’s sample library folders. We recommend naming it ‘Author Name - Library Name’.
2. Create a file in that folder called my-library.floe.lua.
3. Create a subfolder called Samples and put your audio files in there.
4. Open the Lua file in your text editor. If you’re not already familiar with a editor, then Sublime Text or Visual Studio Code are reasonable choices.
5. Use the floe.new_library() function to create your library, filling in all the fields marked [required] in the Floe’s Lua reference.
6. Use floe.new_instrument() to create an instrument, and then add regions to it using floe.add_region(), again, filling in the fields that are documented.
7. At the end of the file, return the library object you just created: return library.
8. Floe automatically detects whenever any library file changes and will tell you if there’s any errors. If a library is correctly configured, it will instantly appear in Floe.

Creating high-quality samples

Levels

It’s important to ensure your audio samples have the the right levels. This makes browsing and switching samples in Floe a consistent, nice experience. Additionally, Floe offers the ability to layer sounds together; this process is more ergonomic when instruments have similar volume levels.

Signet can be a useful tool for changing the levels of your samples.

When changing the volume levels of a realistic multi-sampled instrument, you probably don’t want to normalise each sample individually because part of the character of the instrument is its volume variation. Instead, you should change the gain of the instrument as a whole. Signet has features for this. It also has features for proportionally moving levels towards a target level. This allows you to keep some of the character of an instrument while nudging it towards a more consistent level.

Here are some guidelines for levels:

• Each samples’s peak level should be less than -3 dB.
• Playing the instrument should barely cause Floe’s peak meter to reach its yellow region. Another way to levels could be this: RMS levels for an instrument as a whole should be around -18 dB. Play the instrument polyphonically and watch the RMS level. If the instrument is designed to be monophonic, then adjust for that.
• The noise floor should be as low as possible: -60 dB is a good target. Use high-quality noise reduction tools to remove noise from your samples if you need to. Noise levels can quickly stack up with a multi-sampled instrument played polyphonically. Being too aggressive with algorithmic noise reduction can make your samples sound unnatural - so it’s a balance.
• Impulse responses should be normalised by their energy (power) levels: signet my-impulses norm -100 --mode energy --independently && signet my-impulses norm 0. Or if not using Signet, then adjust their levels so that they feel similar to the volume levels of Floe’s built-in IRs.

Sample rate, bit depth, and file format

Floe only supports FLAC and WAV files. We recommend using FLAC for your samples. It’s lossless and can reduce the file size by 50% to 70% compared to WAV. Floe loads FLAC files very quickly.

We find 44.1 kHz and 16-bit is often a perfectly reasonable choice. 48 kHz and 24-bit might also be appropriate in certain cases.

Volume envelopes of samples

Floe blurs the line between a sampler and a sample-based synthesizer. It has lots of parameters for manipulating the sound in real-time.

If your sample is a single continuous sound, then don’t include a fade-in or fade-out in the sample. Floe has a GUI for volume envelopes that offer more control: they can be adjusted to any value, automated by the DAW, and they are independent of the playback speed of the sample. If you have a sample that is stretched across a keyboard range, it will be sped-up or slowed-down in order to be the correct pitch. If there’s a volume fade, then the speed of the fade will change depending on the pitch of the voice. This is not normally a desirable effect.

If your sound has important timbral variation over time, then don’t cut that away. Only if the sound is a constant tone should you remove the fade in/out.

Library Lua Scripts

The floe.lua file is the most important part of a Floe sample library. This page serves as documentation for all of the functions that you can use in your script to create and configure the library and its instruments.

Floe runs your script using Lua v5.4, providing you with access to these standard libraries: math, string, table and utf8. The other standard libraries are not available - including the require function. This is to minimise security risks.

If there are any errors in your script, Floe will show them on the GUI along with a line number and a description of the problem.

Library Functions

Use these functions to create your sample library. Take note of the [required] annotations - omitting fields marked with these will cause an error.

floe.new_library

Creates a new library. It takes one parameter: a table of configuration. It returns a new library object. You should only create one library in your script. Return the library at the end of your script.

The library is the top-level object. It contains all the instruments, regions, and impulse responses.

local library = floe.new_library({
    -- The name of the library. Keep it short and use tagline for more details. 
    -- [required]
    name = "Iron Vibrations",

    -- A few words to describe the library. [required]
    tagline = "Organic sounds from resonating metal objects",

    -- The URL for this Floe library.
    -- [optional, default: no url]
    library_url = "https://example.com/iron-vibrations",

    -- A description of the library. You can be verbose and use newlines (\n).
    -- [optional, default: no description]
    description = "A collection of resonating metal objects sampled using a handheld stereo recorder.",

    -- Who created this library. Keep it short, use the description for more 
    -- details. [required]
    author = "Found-sound Labs",

    -- URL relating to the author or their work.
    -- [optional, default: ]
    author_url = "https://example.com",

    -- The minor version of this library - backwards-compatible changes are 
    -- allowed on a library; this field represents that. Non-backwards-compatibile 
    -- changes are not allowed: you'd need to create a new library such as: 
    -- "Strings 2".
    -- [optional, default: 1]
    minor_version = 1,

    -- Path relative to this script for the background image. It should be a jpg 
    -- or png.
    -- [optional, default: ]
    background_image_path = "Images/background.jpg",

    -- Path relative to this script for the icon image. It should be a square jpg 
    -- or png.
    -- [optional, default: ]
    icon_image_path = "Images/icon.png",
})

floe.new_instrument

Creates a new instrument on the library. It takes 2 parameters: the library object and a table of configuration. It returns a new instrument object. You can call this function multiple times to create multiple instruments.

An instrument is like a musical instrument. It is a sound-producing entity that consists of one or more samples (samples are specified in regions). Each library can have multiple instruments.

local instrument = floe.new_instrument(library, {
    -- The name of the instrument. Must be unique. [required]
    name = "Metal Fence Strike",

    -- Specify a folder to group instruments under a common heading. It may 
    -- contain slashes to represent a hierarchy. See 
    -- https://floe.audio/develop/tags-and-folders.html for more information.
    -- [optional, default: no folders]
    folder = "Fences/Steel",

    -- A description of the instrument. Start with a capital letter an end with a 
    -- period.
    -- [optional, default: no description]
    description = "Tonal pluck metallic pluck made from striking a steel fence.",

    -- An array of strings to denote properties of the instrument. See 
    -- https://floe.audio/develop/tags-and-folders.html for more information.
    -- [optional, default: no tags]
    tags = { "found sounds", "tonal percussion", "metal", "keys", "cold", "ambient", "IDM", "cinematic" },

    -- Path to an audio file relative to this script that should be used as the 
    -- waveform on Floe's GUI.
    -- [optional, default: first region path]
    waveform_audio_path = "Samples/file1.flac",
})

floe.add_region

Adds a region to an instrument. It takes 2 parameters: the instrument object and a table of configuration. Doesn’t return anything. You can call this function multiple times to create multiple regions.

A region is a part of an instrument. It defines an audio file and the conditions under which it will be played. For example, you might have a region that plays the audio file Piano_C3.flac when the note C3 is played. Each instrument must have one or more regions.

floe.add_region(instrument, {
    -- A path to an audio file, relative to this current lua file. [required]
    path = "Samples/One-shots/Resonating String.flac",

    -- The pitch of the audio file as a number from 0 to 127 (a MIDI note number). 
    -- On a range from 0 to 127. [required]
    root_key = 60,

    -- How this region should be triggered.
    -- [optional, default: defaults]
    trigger_criteria = {
        -- What event triggers this region. Must be one of: "note-on" or 
        -- "note-off".
        -- [optional, default: note-on]
        trigger_event = "note-on",

        -- The pitch range of the keyboard that this region is mapped to. These 
        -- should be MIDI note numbers, from 0 to 128. The start number is 
        -- inclusive, the end is exclusive.
        -- [optional, default: { 60, 64 }]
        key_range = { 60, 64 },

        -- The velocity range of the keyboard that this region is mapped to. This 
        -- should be an array of 2 numbers ranging from 0 to 100. The start number 
        -- is inclusive, the end is exclusive.
        -- [optional, default: { 0, 100 }]
        velocity_range = { 0, 100 },

        -- Trigger this region only on this round-robin index. For example, if 
        -- this index is 0 and there are 2 other groups with round-robin indices 
        -- of 1 and 2, then this region will trigger on every third press of a key 
        -- only.
        -- [optional, default: no round-robin]
        round_robin_index = 0,

        -- If another region in this instrument is triggered at the same time as 
        -- this one and is overlapping this, and also has this option enabled, 
        -- then both regions will play crossfaded in a proportional amount for the 
        -- overlapping area, creating a smooth transition between velocity layers. 
        -- Only works if there's exactly 2 overlapping layers.
        -- [optional, default: false]
        feather_overlapping_velocity_layers = false,

        -- For every region that has this same string, automatically set the start 
        -- and end values for each region's key range based on its root key. Only 
        -- works if all region's velocity range are the same.
        -- [optional, default: no auto-map]
        auto_map_key_range_group = "group1",
    },

    -- Loop configuration.
    -- [optional, default: defaults]
    loop = {
        -- Define a built-in loop.
        -- [optional, default: no built-in loop]
        builtin_loop = {
            -- The start of the loop in frames. Inclusive. It can be negative 
            -- meaning index the file from the end rather than the start. For 
            -- example, -1 == number_frames_in_file, -2 == (number_frames_in_file 
            -- - 1), etc. [required]
            start_frame = 24,

            -- The end of the loop in frames. Exclusive. It can be negative 
            -- meaning index the file from the end rather than the start. For 
            -- example, -1 == number_frames_in_file, -2 == (number_frames_in_file 
            -- - 1), etc. [required]
            end_frame = 6600,

            -- The number of frames to crossfade. [required]
            crossfade = 100,

            -- The mode of the loop. Must be one of: "standard" or "ping-pong".
            -- [optional, default: standard]
            mode = "standard",

            -- If true, the start, end and crossfade values cannot be overriden by 
            -- a custom loop from Floe's GUI.
            -- [optional, default: ]
            lock_loop_points = false,

            -- If true, the loop mode value cannot be overriden by a custom mode 
            -- from Floe's GUI.
            -- [optional, default: ]
            lock_mode = false,
        },

        -- If true, this region will never loop even if there is a user-defined 
        -- loop. Set all regions of an instrument to this to entirely disable 
        -- looping for the instrument.
        -- [optional, default: false]
        never_loop = false,

        -- If true, this region will always loop - either using the built in loop, 
        -- a user defined loop, or a default built-in loop.
        -- [optional, default: false]
        always_loop = false,
    },

    -- Timbre layering configuration.
    -- [optional, default: no timbre layering]
    timbre_layering = {
        -- The start and end point, from 0 to 100, of the Timbre knob on Floe's 
        -- GUI that this region should be heard. You should overlap this range 
        -- with other timbre layer ranges. Floe will create an even crossfade of 
        -- all overlapping sounds. The start number is inclusive, end is 
        -- exclusive. This region's velocity_range should be 0-100.
        -- [optional, default: no timbre layering]
        layer_range = { 0, 50 },
    },

    -- Audio properties.
    -- [optional, default: defaults]
    audio_properties = {
        -- Apply a gain to the audio data in decibels.
        -- [optional, default: 0]
        gain_db = -3,
    },
})

floe.add_ir

Adds an reverb impulse response to the library. It takes 2 parameters: the library object and a table of configuration. Doesn’t return anything. You can call this function multiple times to create multiple impulse responses.

floe.add_ir(library, {
    -- The name of the IR. Must be unique. [required]
    name = "Cathedral",

    -- File path to the impulse response file, relative to this script. [required]
    path = "irs/cathedral.flac",

    -- Specify a folder to group IRs under a common heading. It may contain 
    -- slashes to represent a hierarchy. See 
    -- https://floe.audio/develop/tags-and-folders.html for more information.
    -- [optional, default: no folders]
    folder = "Cathedrals",

    -- An array of strings to denote properties of the IR. See 
    -- https://floe.audio/develop/tags-and-folders.html for more information.
    -- [optional, default: no tags]
    tags = { "acoustic", "cathedral" },

    -- A description of the IR. Start with a capital letter an end with a period.
    -- [optional, default: no description]
    description = "Sine sweep in St. Paul's Cathedral.",
})

floe.set_attribution_requirement

Sets the attribution information for a particular audio file or folder. It takes 2 parameters: a path to the file or folder whose license information you want to set, and a table of configuration. If the path is a folder, the attribution requirement will be applied to all audio files in that folder and its subfolders.

floe.set_attribution_requirement("Samples/bell.flac", {
    -- The title of the work. [required]
    title = "Bell Strike",

    -- Name of the license. [required]
    license_name = "CC-BY-4.0",

    -- URL to the license. [required]
    license_url = "https://creativecommons.org/licenses/by/4.0/",

    -- The name/identification of the persons or entities to attribute the work 
    -- to. [required]
    attributed_to = "John Doe",

    -- URL to the original work if possible.
    -- [optional, default: ]
    attribution_url = "https://example.com",
})

Support Function

Floe provides some additional functions to make developing libraries easier.

floe.extend_table

Extends a table with another table, including all sub-tables. It takes 2 parameters: the base table and the table to extend it with. The base table is not modified. The extension table is modified and returned. It has all the keys of the base table plus all the keys of the extended table. If a key exists in both tables, the value from the extension table is used.

Floe doesn’t have the concept of ‘groups’ like other formats like SFZ or Kontakt have. Instead, this function offers a way to apply a similar configuration to multiple regions. Alternatively, you can use functions and loops in Lua to add regions in a more dynamic way.

local group1 = {
    trigger_criteria = {
        trigger_event = "note-on",
        velocity_range = { 0, 100 },
        auto_map_key_range_group = "group1",
        feather_overlapping_velocity_regions = false,
    },
}

floe.add_region(instrument, floe.extend_table(group1, {
    path = "One-shots/Resonating String 2.flac",
    root_key = 65,
}))

floe.add_region(instrument, floe.extend_table(group1, {
    path = "One-shots/Resonating String 3.flac",
    root_key = 68,
}))

Develop Preset Packs

Developing preset packs is simply a matter of saving preset files into a folder and then packaging them into a Floe Package.

Best practices for presets:

• Makes presets all feel the same volume: the master peak meter on Floe’s GUI should just be the yellow zone when the preset is played at its fullest.
• Give each preset a unique, descriptive name suggesting its tone or usage. Don’t use all capital letters. Don’t include a ‘type’ prefix such as “PAD - “ or “LD - “.
• Add as many tags as is relevant to the preset. Read more about tags on the tags and folders page.
• Keep the description short and ending with a period.
• Organise presets into folders using your file browser. You can rename presets and folders as you like. See the best practises for folders on the tags and folders page.

Package libraries & presets for distribution

The easiest and most reliable way to distribute your Floe sample libraries and presets is with Floe Packages.

Floe Packages are ZIP files that contain Floe sample libraries and/or presets. Packages are the files that users will download and use to install new libraries and presets into Floe.

Floe offers an easy-to-use GUI for installing these Packages. This installation process carefully considers the user’s existing libraries and presets, their versions, their installation preferences, even whether their installed libraries have been modified or not. The result is something that should ‘just work’ or at least provide clear instructions on what to do next.

As with Floe’s sample library format, openness is key. That’s why Floe Packages are just normal ZIP files with a specific structure. Anyone can create them and anyone can open them. Additionally, it gives the user the option to extract them manually rather than use Floe’s GUI if they wish.

Create Floe Packages using our command-line tool or any ZIP program.

Packager command-line tool

If you’re comfortable with such things, we have a command-line tool to create Floe Packages. It ensures everything is set up correctly and adds a couple of nice-to-have features, particularly for users who want to install the package manually rather than with Floe’s GUI.

However, you can use any ZIP program to create Floe Packages. Just make sure they follow the structure described in the next section.

Download

Floe Packager Windows: Download Floe-Packager-v0.8.3-beta-Windows.zip (8 MB)

Floe Packager macOS: Download Floe-Packager-v0.8.3-beta-macOS.zip (1 MB)

Download the program, extract it, and run it from the command line.

Usage

Here’s the output of floe-packager --help:

Takes libraries and presets and turns them into a Floe package file (ZIP).
You can specify multiple libraries and preset-folders. Additionally:
- Validates any Lua files.
- Ensures libraries have a License file.
- Adds an 'About' document for each library.
- Adds a 'Installation' document for the package.
- Embeds a checksum file into the package for better change detection if the package
  is installed manually.

Usage: floe-packager [ARGS]

Optional arguments:
  --library-folders <path>...  One or more library folders
  --presets-folders <path>...  One or more presets folders
  --output-folder <path>       Folder to write the created package to
  --package-name <name>        Package name - inferred from library name if not provided

Examples

These examples use bash syntax.

# Creates a Floe Package from the Slow library and the Slow Factory Presets.
# Slow and "Slow Factory Presets" are folders in the current directory.
./floe-packager --library-folders "Slow" \
                --preset-folders "Slow Factory Presets" \
                --output-folder .

# Creates a Floe Package containing multiple libraries and no presets
./floe-packager --library-folders "C:/Users/Sam/Floe-Dev/Strings" \
                                  "C:/Users/Sam/Floe-Dev/Common-IRs" \
                --output-folder "C:/Users/Sam/Floe-Dev/Releases" \
                --package-name "FrozenPlain - Strings"

Package structure

If you’re not using the packager tool, you need to know the structure of the Floe Package. It’s very simple.

Requirements of a floe package:

• The ZIP must contain a folder called Libraries and/or a folder called Presets. If present, these folders must contain the libraries and presets respectively.

Be careful that your ZIP program is not adding an extra folder when you create the ZIP file. There should not be a top-level folder in the ZIP file, just the Libraries and/or Presets folders.

Example: single library & factory presets

📦FrozenPlain - Arctic Strings Package.zip/
├── 📁Libraries
│   └── 📁Arctic Strings
│       ├── 📄arctic-strings.floe.lua
│       ├── 📁Samples
│       │   ├── 📄strings_c4.flac
│       │   └── 📄strings_d4.flac
│       └── 📁Images
│           ├── 📄background.png
│           └── 📄icon.png
└── 📁Presets
    └── 📁Arctic Strings Factory
        ├── 📁Realistic
        │   ├── 📄Octaved.floe-preset
        │   └── 📄Soft.floe-preset
        └── 📁Synthetic
            ├── 📄Bright.floe-preset
            └── 📄Warm.floe-preset

Example: multiple libraries

📦Audioata - Synthwave Bundle Package.zip/
├── 📁Libraries
│   ├── 📁Synthwave Bass
│   │   ├── 📄synthwave-bass.floe.lua
│   │   └── 📁Samples
│   │       ├── 📄bass_c1.flac
│   │       └── 📄bass_d1.flac
│   ├── 📁Synthwave Drums
│   │   ├── 📄synthwave-drums.floe.lua
│   │   └── 📁Samples
│   │       ├── 📄kick.flac
│   │       └── 📄snare.flac
│   └── 📁Synthwave Synths
│       ├── 📄synthwave-synths.floe.lua
│       └── 📁Samples/
│           ├── 📄synth_c4.flac
│           └── 📄synth_d4.flac
└── 📁Presets
    └── 📁Synthwave Factory
        ├── 📄Clean Pad.floe-preset
        ├── 📄Dirty Lead.floe-preset
        ├── 📄Nebula Drone.floe-preset
        ├── 📄Punchy Kickdrum.floe-preset
        ├── 📄Backing FX.floe-preset
        └── 📄Full Effect.floe-preset

Tags and folders

Floe has 2 complimentary features for browsing, searching and filtering: tags and folders. These apply to a few different features of Floe: presets, instruments and impulse responses.

For developers, there are best practises for how to use tags and folders to offer the best experience for the user.

On this page, we use the term ‘item’ to mean either preset, instrument or impulse response: these all use tags and folders in a similar way.

Folders

Folders are used to group items under a common heading. Items are often displayed in folders, even when other filtering has been applied.

Folders should be categories that relate to the theme or objective of the library. For example, for Lost Reveries, we wanted to explore the technique of using three complimentary timbres to layer into a full-spectrum sound, so we choose folders: “Low”, “Mid” and “Air”. Another example might be a library of field recordings, folders might be “Urban/London”, “Urban/York” or “Nature/New Forest”.

Folders may contain slashes to represent a hierarchy, just like a filepath. For example: “Piano/1978 Steinway”. Use this to specify broad categories that narrow down to specific categories. It’s not usually best to have more than 2 levels of hierarchy.

It’s best to have 5 to 30 items per folder. Folders with not many items clutter the GUI and don’t offer much value. Folders with too many items loose their focus.

Folders might overlap with tags but, in general, they are more abstract and can use phrases that only make sense in the context of the library as a whole. However, if it makes sense to group items under a common heading such as ‘Percussion’ (a common tag), then that’s fine too — but you should also add this as a tag.

Tags

Tags are the properties of an item. They are used for filtering and searching items across all libraries. Therefore, tags should normally come from the standard pool of tags so that there is a common language that enables standard usage across all libraries. Custom tags are allowed, but they should only be used for a good reason.

Add as many relevant tags as possible.

Tags are case-insensitive.

Standard tags

We take a pragmatic approach to defining this set of standard tags. Rather than try to be completely comprehensive and technically accurate, we instead aim to strike a balance between correctness and common usage within the music production space. The goal of tags is to help users find the item they need. You can suggest edits to this list via Github or other means.

For best results setting tags, go over each of the following questions and add all tags that apply to the item.

1. Where did the sound come from? (Sound source)

It’s strongly recommended to specify a sound-source for instruments and impulse responses. This is sometimes not applicable for presets.

2. Does it fit in a real instrument category? (Real instrument type)

piano, keys, strings¹, violin, cello, plucked strings², struck strings³, guitar, bass, brass, wind, percussion, drums, vocal, choir, folk, organ, tonal percussion

Number of instruments: solo, ensemble.

These are mostly relevant for acoustic or hybrid sounds, but can be used for synthesized sounds that emulate these instruments.

3. Is it made from a specific material? (Material)

wood, metal, glass, plastic, rubber, stone, ice.

This is typically used for non-standard instruments in the acoustic or found sounds categories.

3. What reverb type is it? (Reverb type)

small room, large room, chamber, studio, hall, church, cathedral, unusual, open air.

Strongly recommended for impulse responses. Not applicable for instruments or presets.

4. What mood does the item evoke? (Mood)

Positive moods: bright⁴, dreamy, ethereal, hopeful, nostalgic, peaceful, playful. Negative moods: aggressive, chaotic, dark⁵, disturbing, eerie, melancholic, menacing, tense. Mixed moods: bittersweet, hypnotic, mysterious, quirky. Thematic moods: dramatic, dystopian, epic, experimental, fantasy, heroic, noir, romantic, sci-fi, western.

It’s usually recommended to specify moods for synthesised instruments and presets. Not typically used for well-known acoustic instruments.

3. What are its pitch characteristics? (Pitch)

Useful for non-typical sounds that have notable pitch characteristics. A sound is assumed to possess a musical pitch unless otherwise stated.

5. What type of sound is it? (Sound type)

5.1. Does it have a long duration?

5.2. Does it have a short duration?

5.3. Is it a sequence or pattern?

5.4. Does it play a standard role in a track?

6. What is its timbre like? (Timbre)

6.1. Is the sound modulated in some way?

6.2. Does it have a tone similar to a real instrument?

Only use these if the sound isn’t actually from that instrument, but has a similar character.

6.3. Is it related to a synthesis technique?

6.4. What are the frequencies and harmonics like?

7. What genres might this item fit best into? (Genre)

80s, EDM, IDM, ambient, blues, chillout, chiptune, cinematic, disco, downtempo, drum & bass, dubstep, electronic, folk, funk, future bass, glitch, hip-hop, house, industrial, jazz, lo-fi, metal, orchestral, pop, rock, synthwave, techno, trance, trap, vaporwave, world

Specifying at least one genre is recommended for all presets and instruments.

Previously known as Mirage

Floe is a continuation of FrozenPlain’s Mirage plugin (developed from 2018 to 2024). It adds new features and improvements but is similar in a lot of ways. Floe is backwards-compatible with Mirage libraries and presets. Mirage will no longer be developed.

Why the name change?

The project has taken a new direction and so we decided to give it a new name.

• Floe is free and open-source, whereas Mirage was closed-source.
• Floe is not directly tied to FrozenPlain. It’s a separate project that’s open to anyone - we want to encourage growth of Floe without being tied to a specific company.
• Mirage is already the name of a hardware sampler from the 80s - we want to avoid confusion.

Backwards-compatible with Mirage

Floe can load Mirage’s libraries, presets and preferences file. If you have Mirage installed already, Floe will be able to find the same libraries and presets as Mirage.

For this backwards-compatibility to work, you will need to install the Mirage Compatibility package available from FrozenPlain’s website.

You can leave Mirage installed if you want to keep using it: Floe will not interfere with Mirage’s installation.

Floe is a new plugin with a new name and new internals, targeting new plugin formats. Floe can’t replace Mirage automatically in your old, saved DAW projects.

Installation is different

Floe has a new, offline installer. Sample libraries are installed separately using Floe Packages.

Roadmap

Floe is an ongoing project that will have lots of backwards-compatible updates. We want to be able to release new features and improvements as soon as they’re ready.

We’re planning to release Floe v1.0 in Q1 2025. Here’s what we’re working on:

• Finish VST3 and AU support
• Complete the GUI for adding multiple libraries to a single instance
• Recreate the presets infrastructure and GUI
• Comprehensive testing of all plugin formats in all DAWs and operating systems
• Prepare a couple of Floe sample libraries ready for release

Later down the line, we’re planning to:

• Refresh the GUI: make it more consistent and performant, and refactor the code for easier expansion
• Overhaul the audio & MIDI processing engine for easier expansion, such as: MIDI MPE, MIDI2, polyphonic modulation, sample-accurate automation, MIDI learn.
• Add more features to the sample library format to allow for more complex instruments: legato, key-switches, drums, etc.

Even further down the line, we’re looking into:

• Allow for creating custom GUIs ‘views’ using the library Lua API
• Adding wavetable oscillators/granular synthesis as a option to layer with sampled instruments
• Adding a more comprehensive modulation system

Give us feedback on these using Github’s discussions section. FrozenPlain also have a Floe section on their forum.

Changelog

0.8.3-beta

• Fix crash when error occurs in the Windows native file picker
• Fix crash when given invalid arguments to CLAP activate
• Fix crash when opening VST3 in FL Studio on Windows

0.8.2-beta

• Fix crash when trying to randomise instruments, presets or IRs when there’s only one of them
• Fix presets folder still showing tags after a folder is removed. #120
• Fix crash when first opening the GUI

0.8.1-beta

See the main release notes.

• Fix issue where Mirage and Floe libraries with the same name would conflict

0.8.0-beta

First beta release of Floe. This release is feature-complete. We are looking for feedback on the new features and any bugs you find.

• Add AU (Audio Unit v2) support
• Brand new instrument browser supporting tags, search, and filtering by library
• Brand new impulse response browser featuring all the options of the instrument browser
• Brand new preset browser with tags, search, and filtering by library. Preset metadata is tracked, library information is tracked, file changes are detected, duplicate presets are hidden.
• New built-in convolution reverb impulse library with 33 impulse responses
• New save preset dialog with author, description, and tags
• Fix instrument left/right and randomise buttons
• Fix instance ID not retaining
• Fix freeze when trying to resize GUI
• Fix GUI opening but only ever showing black
• Fix randomise parameters

Note: we have jumped from 0.0.7 to 0.8.0. This is to signify the change from alpha to beta but also because it wasn’t really right in the first place only incrementing by the patch number. To make the jump obvious we start the minor version at 0.8.0 rather than 0.1.0.

0.0.7-alpha

The focus of this version has been bug fixes; in particular around loading Mirage libraries and presets.

• Max voice is increased from 32 to 256 allowing for more complex instruments
• Show the instrument type on the GUI: single sample, multisample or oscillator waveform
• Rename ‘Dynamics’ knob to ‘Timbre’ and fix its behaviour - for instruments such as Arctic Strings, it can be used to crossfade between different sets of samples.
• Fix missing code signing on Windows installer resulting in ‘Unknown Publisher’ warning
• Fix layer filter type menu being the incorrect width
• Fix crash when loop points were very close together
• Improve loop modes on GUI: it’s obvious when a loop is built-in or custom, what modes are available for a given instrument, why loop modes are invalid.
• Add docs about looping
• Fix sustain pedal incorrectly ending notes

Mirage loading:

• Fix incorrect loading of Mirage on/off switches - resulting in parameters being on when they should be off
• Fix incorrect handling of Mirage’s ‘always loop’ instruments
• Fix incorrect conversion from Mirage’s effects to Floe’s effects
• Improve sound matching when loading Mirage presets
• Fix failure loading some FrozenPlain Squeaky Gate instruments

Library creation:

• Re-organise the fields for add_region - grouping better into correct sections and allowing for easier expansion in the future.
• Sample library region loops now are custom tables with start_frame, end_frame, crossfade and mode fields instead of an array.
• Add always_loop and never_loop fields to sample library regions allowing for more control over custom loop usage on Floe’s GUI.
• Show an error if there’s more than 2 velocity layers that are using ‘feathering’ mode. We don’t support this yet. Same for timbre layers.

0.0.6-alpha

• Add VST3 support
• Standardise how tags and folders will be used in instruments, presets and impulse responses: https://floe.audio/develop/tags-and-folders.html
• Fix sustain pedal
• Remove ‘retrig CC 64’ parameter from layer MIDI. This was mostly a legacy workaround from Mirage. Instead, we just use the typical behaviour that when you play the same note multiple times while holding the sustain pedal, the note plays again - stacking up.
• Fix package installation crash after removing folders
• Fix markers staying on ADSR envelope even when sound is silent
• Fix MIDI transpose causing notes to never stop
• Fix peak meters dropping to zero unexpectedly
• Fix not finding Mirage libraries/presets folders

0.0.5-alpha

• Fix text being pasted into text field when just pressing ‘V’ rather than ‘Ctrl+V’
• Windows: fix unable to use spacebar in text fields due to the host stealing the keypress
• Fix crash when trying to load or save a preset from file
• Improve the default background image

0.0.4-alpha

Fix crash when opening the preset browser.

0.0.3-alpha

Version 0.0.3-alpha is a big step towards a stable release. There’s been 250 changed files with 17,898 code additions and 7,634 deletions since the last release.

It’s still alpha quality, and CLAP only. But if you’re feeling adventurous, we’d love for you to try it out and give us feedback:

• Download Floe
• Download some libraries
• Install libraries

Error reporting has been a significant focus of this release. We want to be able to fix bugs quickly and make Floe as stable as possible. A part of this is a new a Share Feedback panel on the GUI - please use this!

Floe’s website has been filled out a lot too.

New/edited documentation pages:

• Floe support for using CC BY libraries
• Autosave feature added
• New error reports, crash protection, feedback form
• New uninstaller for Windows

Highlights

• Add new Info panel featuring info about installed libraries. ‘About’, ‘Metrics’ and ‘Licenses’ have been moved here too instead of being separate panels.
• Add new Share Feedback panel for submitting bug reports and feature requests
• Add attribution-required panel which appears when needed with generated copyable text for fulfilling attribution requirements. Synchronised between all instances of Floe. Makes complying with licenses like CC BY easy.
• Add new fields to the Lua API to support license info and attribution, such as CC BY
• Add lots of new content to floe.audio
• Add error reporting. We are now better able to fix bugs. When an error occurs, an anonymous report is sent to us. You can disable this in the preferences. This pairs with the new Share Feedback panel - that form can also be used to report bugs.
• Add autosave feature, which efficiently saves the current state of Floe at a configurable interval. This is useful for recovering from crashes. Configurable in the preferences.
• Add a Floe uninstaller for Windows, integrated into Windows’ ‘Add or Remove Programs’ control panel
• Preferences system is more robust and flexible. Preferences are saved in a small file. It syncs between all instances of Floe - even if the instances are in different processes. Additionally, you can edit the preferences file directly if you want to; the results will be instantly reflected in Floe.
• Improve window resizing: fixed aspect ratio, correct remembering of previous size, correct keyboard show/hide, resizable to any size within a reasonable range.

Other changes

• Add support for packaging and installing MDATA libraries (Mirage)
• Add tooltips to the preferences GUI
• Add ability to select multiple packages to install at once
• Rename ‘settings’ to ‘preferences’ everywhere
• Rename ‘Appearance’ preferences to ‘General’ since it’s small and can be used for other preferences
• Make notifications dismiss themselves after a few seconds
• Fix externally deleted or moved-to-trash libraries not being removed from Floe
• Fix not installing to the chosen location
• Fix Windows installer creating nonsense CLAP folder
• Fix packager adding documents into the actual library rather than the package

0.0.2

• Fix Windows installer crash
• Don’t show a console window with the Windows installer
• Better logo for Windows installer
• Remove unnecessary ‘Floe Folders’ component from macOS installer

0.0.1

This is the first release of Floe. It’s ‘alpha quality’ at the moment - there will be bugs and there are a couple of missing features. This release is designed mostly to test our release process.

This release only contains the CLAP plugin. The VST3 and AU plugins will be released soon.

Mirage

Floe used to be called Mirage. Mirage contained many of the same features seen in Floe v0.0.1. But there are large structural changes, and some new features and improvements:

• Use multiple different libraries in the same instance.
• CLAP version added - VST3 and AU coming soon, VST2 support dropped.
• New installer: offline, no account/download-tickets needed. Libraries are installed separately.
• Ability for anyone to develop sample libraries using new Lua-based sample library format. The new format features a new system to tag instruments and libraries. Hot-reload library development: changes to a library are instantly applied to Floe.
• New comprehensive documentation.
• Floe now can have multiple library and preset folders. It will scan all of them for libraries and presets. This is a much more robust and flexible way to manage assets rather than trying to track individual files.
• New, robust infrastructure:
  • Floe settings are saved in a more robust way avoiding issues with permissions/missing files.
  • Improved default locations for saving libraries and presets to avoid permissions issues.
  • New format for saving presets and DAW state - smaller and faster than before and allows for more expandability.
• New settings GUI.
• Floe packages: a robust way to install libraries and presets. Floe packages are zip files with a particular layout that contain libraries and presets. In the settings of Floe, you can install these packages. It handles all the details of installing/updating libraries and presets. It checks for existing installations and updates them if needed. It even checks if the files of any existing installation have been modified and will ask if you want to replace them. Everything just works as you’d expect.

Technical changes:

• Huge refactor of the codebase to be more maintainable and expandable. There’s still more to be done yet though.
• New build system using Zig; cross-compilation, dependency management, etc.
• Comprehensive CI/CD pipeline for testing and creating release builds.
• New ‘sample library server’, our system for providing libraries and audio files to Floe in a fast, async way.