Morflow Engine & Syntax Reference

# Install standalone native binary via cURL
curl -fsSL https://morflow.org/install.sh | bash

# Or install via NPM (Global CLI)
npm install -g morflow

# Or install via Pip (Python CLI)
pip install morflow

# Verify pipeline syntax, action binaries, and type compatibility
morflow check ./pipeline.morf

# Check with a custom action cache directory
morflow check ./pipeline.morf --path ./actions_cache

# Download required action binaries into local cache
morflow prep ./pipeline.morf

# Force re-download even if action is already present
morflow prep ./pipeline.morf --force

# Download action binaries into a custom directory
morflow prep ./pipeline.morf --path ./actions_cache

# Search for color or audio transformation actions
morflow search color
morflow search biquad

# Inspect argument schemas and SPEC.md docs
morflow spec image_essentials/latest/color_adjust
morflow spec audio_essentials/latest/biquad_filter

# Form 1: Zero-argument actions (parentheses are optional)
to_image
to_wav
identity

# Form 2: Keyword arguments (key=value)
resize(width=512, height=512, filter="bilinear")
color_adjust(contrast=1.15, saturation=1.05, brightness=0.02)
biquad_filter(type="highpass", freq=30.0, sample_rate=48000)

# Form 3: Variable arguments (passing pipeline parameters to action parameters)
resize(width=$target_width, height=$target_height)
resample(to_rate=$target_sample_rate)

# Package-level import (brings actions into scope or under an alias)
import base/latest
import audio_essentials/latest as audio

# Item import (brings specific actions into local scope)
from image_essentials/latest import to_tensor, resize, color_adjust, gaussian_blur, to_image

# Required input passed from host runtime
accept $img_in

# Configurable parameters with default values
accept $target_width = 512
accept $target_height = 512

# The flow starts with the input variable $img_in and passes data step-by-step
$img_in
    >> to_tensor(color="rgb", dtype="f32", layout="hwc", normalize=true)
    >> resize(width=$target_width, height=$target_height, filter="bilinear")
    >> color_adjust(contrast=1.15, saturation=1.05)
    >> gaussian_blur(sigma=1.2)
    >> to_image(color="rgba", dtype="u8")

# Form A: Single primary emission
$img_in >> to_tensor >> resize(width=512, height=512) >> emit

# Form B: Named stream emission
$audio_in >> to_audio >> normalize >> emit("normalized_audio")

# Form C: Intermediate emission with chained downstream processing
$img_in
    >> to_tensor(color="rgb", normalize=true)
    >> resize(width=1024, height=1024)
    >> emit("high_res")               # Emits intermediate 1024x1024 tensor to host
    >> resize(width=256, height=256)   # Continues stream without re-ingesting $img_in
    >> color_adjust(contrast=1.2)
    >> emit("preview")                # Emits downstream preview thumbnail

import audio_essentials/latest
 
accept $input_audio

# FLOW 1: Ingest input audio, convert to structured stream, and tap into $decoded
$input_audio >> to_audio >> $decoded

# FLOW 2: Extract channel 0 (Left), apply low-pass filtering, convert to WAV, and emit
$decoded[0] >> biquad_filter(type="lowpass", freq=1200.0) >> to_wav >> emit("left_filtered")

# FLOW 3: Extract channel 1 (Right), apply high-pass filtering, convert to WAV, and emit
$decoded[1] >> biquad_filter(type="highpass", freq=800.0) >> to_wav >> emit("right_filtered")

# Iterates each channel concurrently in parallel, transforms, and stacks back together
$input_audio
    >> to_audio(sample_rate=44100)
    >> each ($channel) {
        $channel
            >> biquad_filter(type="highpass", freq=30.0, sample_rate=48000)
            >> compressor(threshold_db=-12.0, ratio=3.0)
    }
    >> stereo_widen(width=1.2)   # Receives the stacked multi-channel stream
    >> to_wav
    >> emit

# 1. If / Else branching
if ($sample_rate != 48000) {
    $input_audio >> resample(to_rate=48000) >> $prepared
} else {
    $input_audio >> $prepared
}

# 2. Dynamic route pattern matching
$prepared >> route {
    $channels == 1 => biquad_filter(type="lowpass", freq=1000.0)
    $channels == 2 => stereo_widen(width=1.4)
    else => identity
} >> to_wav >> emit

# Morflow Image Processing Pipeline (.morf)

import base/latest
from image_essentials/latest import to_tensor, resize, color_adjust, gaussian_blur, to_image

accept $img_in
accept $target_width = 512
accept $target_height = 512

# Direct chained dataflow from host image input to emitted output
$img_in
    >> to_tensor(color="rgb", dtype="f32", layout="hwc", normalize=true)
    >> resize(width=$target_width, height=$target_height, filter="bilinear")
    >> color_adjust(contrast=1.15, saturation=1.05, brightness=0.02)
    >> gaussian_blur(sigma=1.2)
    >> to_image(color="rgba", dtype="u8")
    >> emit

# Morflow Audio DSP Pipeline (.morf)

import audio_essentials/latest

accept $input_audio
accept $sample_rate = 44100

# Direct chained DSP processing with inline multi-channel loop
$input_audio
    >> to_audio(sample_rate=$sample_rate)
    >> resample(to_rate=48000)
    >> normalize(target_peak=0.95)
    >> each ($channel) {
        $channel
            >> biquad_filter(type="highpass", freq=30.0, sample_rate=48000)
            >> compressor(threshold_db=-12.0, ratio=3.0)
    }
    >> stereo_widen(width=1.2)
    >> limiter(ceiling_db=-0.1)
    >> to_wav
    >> emit

pip install morflow

import numpy as np
from PIL import Image
import morflow

# 1. Load pipeline from file
pipeline = morflow.load("image_pipeline.morf")

# 2. Pass NumPy arrays directly [H, W, C]
img = Image.open("input.png").convert("RGB")
np_img = np.array(img, dtype=np.uint8)

# 3. Execute pipeline synchronously with native speed
result_np = pipeline.run(np_img)

# 4. Save result
out_img = Image.fromarray(result_np)
out_img.save("output.png")

# ----------------------------------------------------
# Audio Processing (Pass and receive raw WAV bytes)
# ----------------------------------------------------
audio_pipe = morflow.load("audio_pipeline.morf")
with open("input.wav", "rb") as f:
    input_bytes = f.read()

# Single output returns bytes; multi-stream returns dict[str, bytes]
output_wav_bytes = audio_pipe.run(input_bytes)
with open("output.wav", "wb") as f:
    f.write(output_wav_bytes)

npm install morflow

import fs from 'node:fs';
import morflow from 'morflow';

// 1. Load pipeline from file
const pipeline = morflow.load('image_pipeline.morf');

// 2. Construct TensorInput with shape and buffer
const inputBuffer = fs.readFileSync('input_raw_rgb.bin');
const tensorInput = {
  data: inputBuffer,
  shape: [1080, 1920, 3],
  dtype: 'u8'
};

// 3. Run asynchronously off the main thread
const outputTensor = await pipeline.run(tensorInput);

console.log(`Shape: ${outputTensor.shape}, Dtype: ${outputTensor.dtype}`);
const outBuffer = outputTensor.toBuffer();
fs.writeFileSync('output_raw_rgba.bin', outBuffer);

// ----------------------------------------------------
// Audio DSP Execution (Direct Buffer I/O)
// ----------------------------------------------------
const audioPipe = morflow.load('audio_pipeline.morf');
const wavBuffer = fs.readFileSync('input.wav');

// Execute asynchronously
const outWav = await audioPipe.run(wavBuffer);
fs.writeFileSync('output.wav', outWav.toBuffer());

<dependency>
    <groupId>org.morflow</groupId>
    <artifactId>morflow</artifactId>
    <version>0.1.0</version>
</dependency>

import org.morflow.Morflow;
import org.morflow.Pipeline;
import org.morflow.MorflowTensor;
import java.nio.file.Files;
import java.nio.file.Path;

public class MorflowRunner {
    public static void main(String[] args) throws Exception {
        // 1. Load pipeline
        try (Pipeline pipeline = Morflow.load("image_pipeline.morf")) {
            // 2. Wrap image bytes into MorflowTensor [H, W, C]
            byte[] rgbBytes = Files.readAllBytes(Path.of("input_rgb.raw"));
            MorflowTensor inputTensor = MorflowTensor.fromByteArray(
                rgbBytes,
                new int[]{1080, 1920, 3}
            );

            // 3. Execute pipeline
            try (MorflowTensor outputTensor = pipeline.run(inputTensor)) {
                int[] outShape = outputTensor.getShape();
                byte[] outBytes = outputTensor.toByteArray();
                Files.write(Path.of("output.raw"), outBytes);
            }
        }

        // Audio WAV execution
        Pipeline audioPipe = Morflow.load("audio_pipeline.morf");
        byte[] inputWav = Files.readAllBytes(Path.of("input.wav"));
        MorflowTensor audioOut = audioPipe.run(inputWav);
        Files.write(Path.of("output.wav"), audioOut.toByteArray());
    }
}

cargo add morflow

use morflow::{ColorSpace, Image, Morflow, Payload, RVec};
use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Load pipeline from file
    let mut pipeline = Morflow::load("image_pipeline.morf")?;

    // 2. Wrap image buffer into a Morflow Image payload
    let img = image::open("input.png")?.to_rgb8();
    let input = Image::from_u8_hwc(
        &img,
        img.width() as usize,
        img.height() as usize,
        ColorSpace::Rgb,
    ).map_err(|e| e.to_string())?;

    // 3. Execute Morflow pipeline
    let outputs = pipeline.run(Payload::Image(input))?;

    // 4. Extract emitted payload and save output
    if let Payload::Image(out) = outputs.into_single()? {
        let bytes = out.to_contiguous_bytes();
        image::save_buffer(
            "output.png",
            bytes.as_slice(),
            out.width() as u32,
            out.height() as u32,
            image::ColorType::Rgba8,
        )?;
    }

    // ----------------------------------------------------
    // Audio DSP Execution (Direct Data Payload)
    // ----------------------------------------------------
    let mut audio_pipe = Morflow::load("audio_pipeline.morf")?;
    let wav_bytes = fs::read("input.wav")?;

    let audio_out = audio_pipe.run(Payload::Data {
        buffer: RVec::from(wav_bytes),
    })?;

    if let Payload::Data { buffer } = audio_out.into_single()? {
        fs::write("output.wav", buffer.as_slice())?;
    }

    Ok(())
}