Palmier Pro: An Open-Source macOS Video Editor Built from the Ground Up for AI Pipelines

What Happened: A Native macOS Editor That Speaks JSON

A new open-source project called Palmier Pro landed on Hacker News this week, and it’s a deliberate departure from the bloated NLE (Non-Linear Editor) category. The source is available on GitHub, and the pitch is surgical: a macOS-native video editor built not for the manual timeline jockey, but for the developer who treats video as structured data.

This isn’t DaVinci Resolve or Final Cut Pro. It’s a Swift-based, AppKit-native application that renders video via Core Animation and AVFoundation. The UI is a composable timeline, but the real product is the project file: a human-readable JSON document that describes every track, effect, keyframe, and mask. The entire state of the editor is serialized to this file. When you save in Palmier Pro, you aren't exporting XML—you're dumping the exact state machine that drives the rendering engine.

For engineers, this flips the script. Video editing stops being a GUI-only activity and becomes a programmable pipeline where you can generate, mutate, and optimize project files with a Python script, an LLM, or a CI runner.

Why Engineers Should Care: The End of Pixel-Streaming Hacks

If you've ever built an automated video generation pipeline, you know the pain. The standard workflow is a brittle stack of headless Chromium, Remotion, or FFmpeg filter chains. You're either puppeteering a browser to capture frames, or you're fighting with filter graphs that look like arcane incantations.

Palmier Pro represents a third path: native rendering with a programmable state layer.

Here's the core insight for a Forward Deployed Engineer (FDE): when you integrate AI into a customer's video workflow, the bottleneck is almost never the model. It's the rendering engine. The customer doesn't just want a script; they want the final 4K ProRes file with branded overlays, dynamic text, and audio ducking—all generated from a single prompt.

Palmier Pro lets you treat the project file as the integration surface. An LLM generates JSON; Palmier Pro renders it natively. No browser, no screen recording, no lossy re-encodes. The pipeline becomes:

1. LLM generates a structured script and shot list.
2. Python maps that script to a Palmier Pro .plm JSON project file, inserting source media paths, text overlays, and transitions.
3. Palmier Pro CLI (or a headless mode) renders the master file directly via AVFoundation hardware encoding.

This is the same architectural pattern we explore when building AI analysts over structured data. You're not asking the model to output pixels; you're asking it to output a high-level representation (SQL, or in this case, a timeline JSON) that a deterministic, high-performance engine executes. The model handles the messy logic; the engine handles the precise rendering. This separation of concerns is what makes the output production-grade.

Under the Hood: The AI-Native Architecture

Palmier Pro's architecture is worth studying because it solves the "last mile" problem of AI video. Let's break down the components that matter for pipeline builders.

The Project File as API Contract

The .plm file is a flat JSON object. Key sections include:

• media: An array of source clips with in/out points.
• tracks: The timeline structure. Each track is an ordered list of clip references.
• effects: A dictionary of effect stacks (color correction, transforms, masks) applied per clip.
• audio: Volume envelopes and audio track mappings.

Because this is pure JSON, you can validate it with JSON Schema, generate it with a Jinja template, or diff it in Git. This is a game-changer for collaboration. Two engineers can work on different segments of a video by editing separate JSON patches, then merge them programmatically. Try doing that with a .fcpxml file.

Rendering Without a GUI

The current public release is a full GUI application, but the architecture cleanly separates the rendering engine from the view layer. The core PalmierKit framework handles all compositing and encoding. For pipeline use, the immediate need is a headless CLI mode. The project maintainers have indicated this is a priority. Once available, you'll be able to run:

palmier-cli render --project project.plm --output final.mov --preset prores-4444

This would slot directly into a GitHub Actions workflow for automated video asset generation. Imagine a CI pipeline where a product launch triggers an automatic social cut generation, complete with the latest pricing overlays pulled from a CMS.

Why macOS-Native Matters

Choosing AppKit and AVFoundation isn't a casual decision; it's a deliberate trade-off for performance. AVFoundation's hardware encoders on Apple Silicon are absurdly fast. A MacBook Pro can encode ProRes 422 HQ at multiples of real-time. By building on the native stack, Palmier Pro inherits this speed for free. There's no FFmpeg compile-flag roulette. The render output is bit-for-bit deterministic, which is critical for automated QA.

How to Use It Today: The Quickstart Pipeline

You can build a working automated video pipeline with Palmier Pro right now, even without a headless CLI. The trick is to treat the GUI as a render farm that watches a folder.

Step 1: Clone and Build

git clone https://github.com/palmier-io/palmier-pro.git
cd palmier-pro
open PalmierPro.xcodeproj

Build the project in Xcode (requires macOS 14+, Apple Silicon recommended). The app will launch as a standard desktop editor.

Step 2: Generate a Project File

Write a Python script that outputs a .plm file. Start by creating a simple project in the GUI, saving it, and inspecting the JSON structure. Then, reverse-engineer the schema you need. For a basic AI-generated short, your script might look like this:

import json

def build_project(script_segments, media_paths):
    tracks = []
    for i, (text, path) in enumerate(zip(script_segments, media_paths)):
        clip = {
            "id": f"clip_{i}",
            "source": path,
            "in": 0,
            "out": 5.0,
            "effects": [
                {
                    "type": "text_overlay",
                    "string": text,
                    "font": "SF Pro Display",
                    "size": 48,
                    "position": [0.5, 0.8]
                }
            ]
        }
        tracks.append(clip)
    
    project = {
        "version": "1.0",
        "resolution": [1920, 1080],
        "frame_rate": 30,
        "tracks": {"video": tracks},
        "audio": []
    }
    
    with open("output.plm", "w") as f:
        json.dump(project, f, indent=2)

Step 3: Render via GUI

Open the generated output.plm in Palmier Pro. If the JSON is valid, the timeline will populate. Hit Export. It's manual, but it validates the entire pipeline. You can then automate the "Open and Export" step using macOS's osascript to script the GUI until the CLI lands:

osascript -e 'tell application "PalmierPro" to open POSIX file "/path/to/output.plm"'
# Add a delay, then trigger export via keyboard shortcut

Step 4: Integrate with AI

The real power comes when you connect this to an LLM. The pattern is identical to building a document extraction pipeline that turns PDFs into structured JSON. Your prompt engineering task shifts from "generate a video" to "generate a JSON timeline that represents a video." This is a much more constrained, testable problem. You can validate the JSON output against a schema before it ever hits the renderer. If the JSON is malformed, you retry the LLM call. If the JSON is valid but the video looks wrong, you tweak the prompt template, not the rendering code.

This separation of AI logic from deterministic rendering is a core competency for an FDE. You're not just throwing a prompt at a black box; you're engineering a system where the AI controls the semantic intent and a native engine guarantees the pixel-perfect output. This mirrors the architecture we use when building automated code review bots that reason about logic and style. The LLM provides the intelligence; the Git integration provides the deterministic action.

The Balanced Take: Where It Shines and Where It Breaks

Palmier Pro is not a Final Cut Pro replacement, and it doesn't want to be. Evaluating it honestly means understanding its ideal workload and its current sharp edges.

Strengths

• AI Pipeline Fit: This is the first video editor I've seen that treats project serialization as a first-class design goal. The JSON is clean, not an afterthought.
• Native Performance: AVFoundation encoding on Apple Silicon is production-grade and battery-efficient. You can render on a MacBook Air without it melting.
• Composable Architecture: The separation of PalmierKit from the GUI means a headless mode is architecturally straightforward, not a rewrite.
• Diffable Projects: .plm files in Git are actually meaningful. You can review a "video change" in a pull request by looking at the JSON diff.

Weaknesses

• No Headless CLI Yet: This is the single biggest gap for pipeline use. Scripting the GUI with AppleScript is a hack, not a solution. Until palmier-cli ships, it's not ready for lights-out automation.
• macOS-Only: The reliance on AppKit and AVFoundation means this will never run on Linux servers. For cloud-native pipelines, you'd need a Mac mini farm or MacStadium. This adds cost and complexity compared to pure FFmpeg or headless Chromium solutions.
• Early Stage: The project is new. The JSON schema is undocumented and likely unstable. Building a production pipeline on it today means you're committing to maintaining your own parser as the schema evolves.
• Limited Format Support: It inherits AVFoundation's codec support, which is broad but not as exhaustive as FFmpeg's. If you need obscure codec support, you'll still need FFmpeg in the loop for transcoding.

The FDE Angle

For a Forward Deployed Engineer, Palmier Pro represents a specific type of tool: the high-leverage platform wedge. It's not a general-purpose editor. It's a rendering engine with a programmable interface. If you have a customer who needs to generate thousands of localized video variants from a template, this is your foundation. You build the template once in the GUI, parameterize the .plm file, and let an LLM or a rules engine generate the variants.

The skill to develop here is context engineering—not just for LLMs, but for rendering engines. You need to understand the rendering pipeline deeply enough to know what the JSON should express, and you need to structure your LLM prompts to produce valid, useful timelines. This is the same discipline we apply when structuring prompts for models that actually read the documentation. You're not hoping the AI gets it right; you're engineering a constrained output format that leaves no room for hallucination.

FAQ

Q: Can I run Palmier Pro on a Linux server for automated rendering? A: No. It's built on Apple's AppKit and AVFoundation, so it requires macOS. For headless server rendering, you'd need a Mac mini or a Mac cloud provider. If Linux is a hard requirement, you're better off with FFmpeg-based pipelines or a tool like Remotion for now.

Q: How does this compare to Remotion? A: Remotion renders video by capturing frames from a React application running in headless Chromium. This is flexible (you can use any web technology) but slow and memory-intensive. Palmier Pro renders natively via AVFoundation, which is much faster and more resource-efficient, but you lose the flexibility of the web ecosystem. Choose Remotion for complex, dynamic layouts; choose Palmier Pro for high-volume, template-driven rendering where speed matters.

Q: Is the .plm JSON format stable enough for production? A: Not yet. The project is early-stage, and the schema is evolving. For production use, you should pin to a specific commit and be prepared to update your generation scripts as the format changes. Treat it as a powerful alpha.

Q: What's the minimum macOS version? A: macOS 14 (Sonoma) or later, with Apple Silicon strongly recommended for hardware-accelerated encoding performance.

Q: Can I use this to build a fully automated AI video generator today? A: You can build the pipeline logic, but the final render step currently requires opening the GUI. You can script this with AppleScript as a stopgap, but a true hands-off pipeline needs the headless CLI, which is on the roadmap but not yet in the public release.

Q: How does this fit into an FDE's toolkit? A: Palmier Pro is a domain-specific rendering engine. An FDE would use it when a customer needs to automate video production at scale—think personalized sales outreach, automated social media cuts, or localized training content. The FDE's job is to wire the LLM to the JSON generator, the JSON to the renderer, and the renderer to the customer's distribution pipeline. It's a classic FDE pattern: a high-touch integration that directly drives revenue and time-to-value.