# Build your own plug-in collection

> What a product team reuses to build its own instruments and effects on Maru, the path from a new project to a module running in your web product, and how to arrange the license.

Canonical: https://maru.audio/docs/build-your-own-plugin-collection
Documentation index: https://maru.audio/llms.txt

A product team can build its own instruments and effects on Maru's module
framework instead of writing an audio engine, a parameter and preset system or
a control library. Each product is one module project: its DSP, interface,
presets and assets live together, and the same project builds the browser
Release your web product hosts. Arrange the license before you start; the
framework is not open source.

> **In the Help Center:** [DAWs and audio software makers](https://maru.audio/help/daw-and-audio-software-makers.md) for planning a partnership and its scope.

## What you reuse

| Part | What it gives your products | Read |
| --- | --- | --- |
| Module contract | One declaration per product (ports, parameter schema, presets and identity), a Graph or Processor for the sound, an optional face, presets and assets in one project | [Define a Processor module](https://maru.audio/docs/processor-module.md) |
| DSP library | Prepared, bounded building blocks for filters, dynamics, delays, reverbs, voices, sampling and more, imported from `maruaudio/dsp/*` inside your Processor | [DSP library](https://maru.audio/docs/dsp.md) |
| UI kit and theming | Knobs, faders, meters and preset controls bound to your parameter schema from `maruaudio/ui/module-face-controls`; your palette, finish and type set with `--uikit-*` variables on the face wrapper | [Customize your interface](https://maru.audio/docs/customizing-plugin-ui.md) |
| Scaffolding and the development loop | `npm create maru` or `maru init` with Processor and Graph starters, and the `maru dev` workbench, which reloads a face without restarting audio | [Create a project](https://maru.audio/docs/create.md), [Development workbench](https://maru.audio/docs/dev.md) |
| The module player | Your built Releases playing inside your own web app, with your own transport and controls | [Host Maru modules in a web DAW](https://maru.audio/docs/host-modules-in-a-web-daw.md) |

A face never makes sound or opens devices: the host owns audio, MIDI,
parameter state and presets, and the face sends edits to it. That boundary is
what lets your web product drive a module with its own controls, or show the
module's face, without changing its sound.

## From a new project to your web product

1. **Create a project.** Start from the starter closest to the product:

   ```bash
   npm create maru@latest my-pedal
   npm create maru@latest my-synth -- --kind processor-instrument
   ```

   The default is a Processor effect. `processor-instrument`, `effect` and
   `instrument` are the other kinds.
2. **Write the sound and the face.** Compose the Processor from DSP library
   blocks, declare its parameters and factory presets, and build the face
   from UI-kit controls in your own palette.
3. **Iterate.** Run `maru dev` and play the module while you change it.
4. **Check it.** Run `maru module check`, then measure rendered audio from the
   built module. A passing check or a finite output is not approval of the
   sound; listen to it and report that separately.
5. **Build the web Release.** `maru module build` produces the browser Release;
   `maru module pack` prepares a versioned Release locally without uploading
   it. [Check, build and export](https://maru.audio/docs/export.md) covers both.
6. **Publish or serve it yourself.** `maru publish` uploads a release to Maru,
   public or unlisted ([Publishing](https://maru.audio/docs/publishing.md)). To keep a
   collection off Maru's site, serve the built Releases from your own
   infrastructure instead; web playback needs no Maru account.
7. **Host it in your product.** Load each Release with the module player,
   pinned by its digest, as an instrument or a track insert.
8. **Ship new versions deliberately.** A change to the sound, face or presets
   is a new Release with a new digest. Keep earlier Releases available where
   you serve them: a saved project reopens only the Release it pinned, so
   moving projects to a new version is a step you take on purpose.

The same project can also be built as native plug-ins with
`maru plugin build`, described in [Native plugins](https://maru.audio/docs/native-plugins.md).
Native builds use Maru's native toolkit, which requires approved access, and
each format and platform is built and tested on its own. Ask about native
targets when you contact us.

## Arrange the license first

[Licensing](https://maru.audio/docs/licensing.md) states the current terms.
Maru-authored modules, DSP and SDK source is publicly visible as a research
preview, with the notice **Source available · all rights reserved** wherever no
separate license is declared. No license or other rights to use, copy, modify,
redistribute or sell this code are granted unless explicitly specified in
separate terms. The SDK, compiler, CLI, examples and generated native shells
are not published under a general open-source license.

Building and distributing a collection on the framework therefore needs
written terms from Maru. [Contact Maru](https://maru.audio/contact) with the products you want
to build, where they will run (your web product, your desktop app or both)
and how you plan to distribute them.
