MFlow v0.4.1 — User-Local Installation

MFlow v0.4.1 — User-Local Installation

MFlow v0.4.1 introduces the first complete user-local installation system for MFlow.

✨ Highlights

• User-local installation on Windows
• User-local installation on Linux
• mflow available from any terminal and directory
• Automatic Windows user PATH configuration
• Linux ~/.local/bin installation support
• Version updated to 0.4.1
• No external multimedia executable is required

🛠️ Installation

Windows

Run:

powershell -ExecutionPolicy Bypass -File .\scripts\install-windows.ps1

Then open a new terminal and run:

mflow version
mflow info

Linux

Run:

chmod +x ./scripts/install-linux.sh
./scripts/install-linux.sh

Then:

mflow version
mflow info

📦 Current capabilities

MFlow currently provides the native media foundation required for future multimedia processing:

• Packet model
• Stream model
• Timestamps
• Thread-safe packet queues
• Media contexts
• Native file operations
• Native media probing foundation
• Scheduler and pipeline infrastructure
• Cross-platform C++20 architecture

🚧 Current limitations

Native codec decoding/encoding, full demuxing/muxing and advanced media transformations are still under development.

MFlow does not delegate multimedia processing to FFmpeg or another external multimedia executable.

🔜 Next

The v0.4.x series will continue building the native media engine, including improved packet queues, media contexts and the first native container components.

Previous release: v0.4.0 — Packet & Stream Foundation

MFlow v0.4.0 — Native Packet & Stream Foundation

MFlow v0.4.0 — Native Packet & Stream Foundation

MFlow v0.4.0 introduces the first reusable native media data model of the MFlow engine.

🚀 What's new

• Native Packet system
• Native Stream model for video, audio and data streams
• Rational Timestamp system with PTS, DTS and duration
• Thread-safe PacketQueue
• MediaContext for managing containers and streams
• Pipeline stages now operate directly on MFlow packets
• Expanded automated test coverage
• Native C++20 architecture preserved across Windows and Linux

🧠 Core architecture

MFlow now has the foundations required for a real native media processing pipeline:

INPUT
  ↓
MEDIA CONTEXT
  ↓
STREAMS
  ↓
PACKETS
  ↓
PACKET QUEUE
  ↓
PIPELINE

Packets now carry their stream ID, timestamps, duration, flags and sequence information.

This provides the foundation for future native demuxers, frame processing, codecs and muxers.

⚡ Design philosophy

MFlow continues to follow its core principle:

Move less data. Do less work. Measure everything.

The architecture is designed to avoid unnecessary copies, decoding, encoding, memory transfers and processing whenever the requested operation does not require them.

🔒 No FFmpeg dependency

MFlow does not delegate media processing to FFmpeg or another external multimedia executable.

The engine is being developed as an independent native multimedia stack.

⚠️ Current limitations

v0.4.0 does not yet provide:

• Native MP4 demuxing
• Native MP4 muxing
• Native video decoding
• Native video encoding
• Native audio decoding
• Native audio encoding
• Video scaling
• General-purpose media transcoding

These capabilities are being developed progressively.

🛣️ Next steps

The next development stages will focus on:

• Timestamp normalization and ordering
• Native MP4 box parsing
• Native MP4 demuxer
• Native MP4 muxer
• Raw video frame system
• Audio sample system
• Native codec foundations

MFlow is still in active development, but v0.4.0 establishes an important foundation for the future native media engine.

📦 Build

Requirements:

• C++20 compiler
• CMake
• Windows or Linux

Build with:

cmake -S . -B build
cmake --build build --config Release

📄 License

MFlow is released under the MIT License.

MFlow v0.3.0 — Native Media Engine Foundation

MFlow v0.3.0 marks the transition to a native multimedia engine.

This release removes the external media-backend approach and establishes the foundations for independent multimedia processing on Windows and Linux.

What's New

• Native media engine foundation
• Native file and stream copy
• Native media format probing
• Buffered I/O
• Cross-platform C++20 support
• Scheduler, pipeline and memory foundations
• Improved CLI information and diagnostics
• Explicit handling of unsupported native operations

Independence

MFlow does not invoke or require FFmpeg or another external multimedia executable.

MFlow is being developed as an independent multimedia engine, with codecs, demuxers, muxers and advanced processing being implemented progressively in future releases.

Current Limitations

Codec transcoding, scaling, native demuxing/muxing and advanced media processing are not fully implemented yet.

Roadmap

Upcoming releases will introduce:

• Packet and stream systems
• Timestamp handling
• Native MP4 parsing
• Native demuxing and muxing
• Frame and audio sample systems
• Native codecs
• Zero-copy processing
• Hardware acceleration

Platforms

• Windows
• Linux

Build

Requires CMake 3.20+ and a C++20 compiler.

MFlow is open source and designed to remain local, transparent and independent.

MFlow v0.2.0 — Native Media Engine Foundation

MFlow v0.2.0 — Native Media Engine Foundation 🚀

MFlow v0.2.0 begins the transition from a multimedia execution framework into a fully independent media engine.

The goal is simple:

Move less data. Do less work. Measure everything.

✨ What's new

🧩 Native media architecture

MFlow is designed to process media through its own execution architecture instead of depending on FFmpeg or another external multimedia executable.

The engine is being built around:

INPUT
  ↓
STREAM PLANNER
  ↓
WORK GRAPH
  ├── VIDEO
  │    ↓
  │  DECODE → FILTER → ENCODE
  │
  └── AUDIO
       ↓
     DECODE → PROCESS → ENCODE
  ↓
MUX
  ↓
OUTPUT

⚡ Work-aware processing

MFlow is designed to avoid operations that are not required by the requested result.

For example, when a stream can be copied without modification, the engine should be able to avoid unnecessary decoding and re-encoding:

INPUT
  ↓
STREAM ANALYSIS
  ↓
COMPATIBLE STREAM
  ↓
DIRECT COPY
  ↓
OUTPUT

Instead of:

DECODE → CONVERT → ENCODE

This architecture is the foundation for future stream-copy and zero-copy optimizations.

💾 Memory architecture

The project continues developing its memory management layer around:

• reusable buffers
• controlled allocations
• reduced memory copies
• buffer lifetime tracking
• future zero-copy execution

🧵 Execution engine

The scheduler and pipeline system introduced in v0.1 continue to form the execution layer of MFlow.

The long-term goal is to make scheduling media-aware rather than simply distributing generic tasks across CPU threads.

🖥️ Hardware-aware design

MFlow's architecture is being prepared for hardware-specific execution paths.

The intended model is:

GPU DECODE
     ↓
GPU FILTER
     ↓
GPU RESIZE
     ↓
GPU ENCODE

without unnecessary:

GPU → RAM → GPU

transfers.

🎯 What makes MFlow different?

MFlow is not intended to be a command-line clone of FFmpeg.

The project is being designed around a different execution philosophy:

Understand the requested result first, then perform only the work required to produce it.

This means the stream planner can eventually reason about:

• which streams are actually needed
• whether decoding is necessary
• whether re-encoding is necessary
• whether a format conversion is necessary
• where data should live
• which processing stages can be fused
• which hardware path should be used
• how buffers can be reused

🏗️ Current status

MFlow v0.2.0 is an early native-engine milestone.

This release establishes the architecture required for native multimedia processing. It should not yet be considered a complete replacement for mature multimedia frameworks.

Native container parsers, codecs, muxers and hardware acceleration are being developed incrementally.

🛣️ Next milestones

v0.3

• Native media container layer
• Stream model
• Packet model
• Timestamp handling
• Native demux foundation
• Real media fixtures
• Media-specific benchmarks

v0.4

• Native codec implementations
• Frame management
• Pixel formats
• Audio sample formats
• Native encode/decode paths

v0.5

• Zero-copy execution
• Buffer lifetime planning
• Pipeline fusion
• Asynchronous I/O
• Hardware acceleration foundations

v1.0

• Stable native media API
• Multiple containers
• Multiple video codecs
• Multiple audio codecs
• Hardware acceleration
• Cross-platform releases
• Reproducible performance benchmarks

📊 Benchmark philosophy

MFlow does not publish performance claims without reproducible measurements.

Benchmarks should document:

• CPU
• GPU
• RAM
• operating system
• compiler
• MFlow version
• input media
• output format
• processing parameters

🔓 Open source

MFlow is completely open-source and licensed under MIT.

The project is being developed with a long-term goal of providing an independent, efficient and locally executable multimedia engine.

MFlow v0.2.0

Native media engine foundation.

Move less data. Do less work. Measure everything.

MFlow v0.1.0 — Foundation Release

MFlow v0.1.0 — Foundation Release 🚀

MFlow v0.1.0 introduces the foundation of a new high-performance multimedia processing engine focused on efficiency, modularity and intelligent resource management.

✨ Highlights

• ⚡ Modular processing pipeline
• 🧠 Resource-aware execution architecture
• 💾 Memory pooling foundation
• 🧵 Parallel task scheduler
• 🔍 Basic media format detection
• 🖥️ System capability detection
• 💻 Cross-platform C++20 build system
• 🛠️ Command-line interface
• 🧪 Automated tests
• 📊 Performance benchmarks
• 📚 Architecture and roadmap documentation
• 🔧 Developer pipeline example

🧩 Core Architecture

MFlow introduces a modular processing model designed around:

INPUT → PROCESS → OUTPUT

The architecture is designed to minimize unnecessary work, memory allocations, data copies and processing overhead.

🧪 Tested on Windows

The v0.1.0 build has been successfully compiled and executed on Windows x86_64.

Example system detection:

• Platform: Windows
• Architecture: x86_64
• Hardware threads: 12
• Recommended workers: 10

The scheduler benchmark successfully processed 200,000 tasks.

The pipeline demonstration successfully processed 4 packets through:

source → transform → sink

⚠️ Development Status

MFlow v0.1.0 is an early foundation release.

It establishes the core architecture and development infrastructure. Full media decoding, encoding, advanced hardware acceleration and optimized media I/O are planned for future releases.

🎯 Design Principle

Don't process what you don't need.

MFlow is being built around the idea that efficient media processing should minimize unnecessary computation, memory movement and data processing.

📌 Version

v0.1.0

Status: Early Development 🟡

License: MIT