Multi-Language Processing

Modern backend development often requires combining the strengths of different programming languages. TypeScript for APIs, Python for data processing and AI, JavaScript for rapid prototyping. Traditional approaches involve complex microservices architectures with intricate communication patterns.

This comprehensive guide explores how to build a unified multi-language data processing pipeline using Motia's step primitive. We'll cover:

1. Steps as Core Primitive: How steps unify different languages under a single abstraction.
2. Building the Pipeline: A step-by-step guide to creating a cohesive multi-language data processing workflow.
3. Unified Execution Model: How steps enable seamless communication between different runtime environments.
4. Hands-On Development: How to build, run, and observe your unified multi-language pipeline.

Let's build a production-ready data processing system where steps unify TypeScript, Python, and JavaScript into a single cohesive workflow.

The Power of Steps: A Unified Multi-Language Primitive

At its core, our data processing pipeline demonstrates how steps solve the fundamental challenge of multi-language systems: unifying different programming languages under a single, coherent abstraction. Traditional polyglot architectures require complex inter-process communication and deployment coordination. Motia's step primitive unifies everything.

Steps enable true language unification:

• TypeScript steps: Strong typing and excellent tooling for APIs and orchestration
• Python steps: Rich ecosystem for data processing, ML, and scientific computing
• JavaScript steps: Dynamic processing and rapid development
• Motia's Step Primitive: The unifying abstraction that makes all languages work as a single system

Instead of managing multiple services, steps provide a single programming model. Whether written in TypeScript, Python, or JavaScript, every step follows the same pattern: receive data, process it, emit events. This unification is what makes multi-language development straightforward.

The Anatomy of Our Multi-Language Pipeline

Our application consists of six specialized steps, each leveraging the optimal language for its specific task. Let's explore the complete architecture.

import { z } from 'zod'
 
const bodySchema = z.object({
  data: z.record(z.unknown()).optional(),
  message: z.string().optional()
})
 
// API endpoint to start the multi-language pipeline
export const config = {
  type: 'api',
  name: 'AppStarter',
  description: 'Start the multi-language app pipeline',
 
  method: 'POST',
  path: '/start-app',
 
  bodySchema,
  responseSchema: {
    200: z.object({
      message: z.string(),
      appId: z.number(),
      traceId: z.string()
    })
  },
 
  emits: ['app.started'],
  flows: ['data-processing']
} as const
 
export const handler = async (req: any, { logger, emit, traceId }: any) => {
  logger.info('🚀 Starting multi-language app', { body: req.body, traceId })
  
  const appData = {
    id: Date.now(),
    input: req.body.data || {},
    started_at: new Date().toISOString(),
    traceId
  }
 
  // Emit to next step
  await emit({
    topic: 'app.started',
    data: appData
  })
 
  logger.info('✅ App started successfully', { 
    appId: appData.id,
    traceId 
  })
 
  return {
    status: 200,
    body: {
      message: 'Multi-language app started successfully',
      appId: appData.id,
      traceId
    }
  }
}

Type Definitions

Our unified system uses shared TypeScript types to ensure type safety across the multi-language pipeline:

// types/index.ts
export interface AppData {
  id: number
  input: Record<string, unknown>
  started_at: string
  traceId: string
}
 
export interface ProcessedResult {
  original_id: number
  processed_at: string
  result: string
  confidence: number
  model_version: string
}
 
export interface PythonResult {
  id: number
  python_message: string
  processed_by: string[]
  processing_time: number
}
 
export interface NotificationData {
  id: number
  message: string
  processed_by: string[]
  sent_at: string
}
 
export interface AppSummary {
  appId: number
  status: string
  completed_at: string
  steps_executed: string[]
  result: string
}

Explore the Workbench

The Motia Workbench provides a visual representation of your multi-language pipeline, making it easy to trace data flow between TypeScript, Python, and JavaScript steps.

You can monitor real-time execution, view logs from all languages in a unified interface, and trace the complete data flow from the TypeScript API through Python processing to JavaScript summary generation.

Event Flow Architecture

The pipeline follows a clear event-driven flow that connects all languages seamlessly:

1. app.started - TypeScript API → TypeScript Bridge
2. data.processed - TypeScript Bridge → Python Processor
3. python.done - Python Processor → TypeScript Notification Handler
4. notification.sent - TypeScript Notification → TypeScript Finalizer
5. app.completed - TypeScript Finalizer → JavaScript Summary Generator

Each step only needs to know the events it subscribes to and emits, creating loose coupling while maintaining strong data flow guarantees.

Key Features & Benefits

🧩 Step as Universal Primitive

Every piece of logic—whether TypeScript, Python, or JavaScript—follows the same step pattern, creating true unification.

🌐 Seamless Language Integration

Steps eliminate the complexity of multi-language systems by providing a unified programming model.

📊 Unified Development Experience

Write, debug, and monitor all languages through a single interface and shared execution model.

⚡ Hot Reload Across Languages

Edit any step in any language and see changes instantly across the entire pipeline.

🔄 Event-Driven Communication

Steps communicate through events, enabling loose coupling and independent scaling.

🎯 Single Deployment Model

Deploy all languages together as a cohesive system, not as separate microservices.

🐍 Python Step Naming

Python steps use the _step.py suffix convention for proper module resolution (e.g., simple-python_step.py).

Trying It Out

Ready to build your first multi-language Motia application? Let's get it running.

npx motia@latest create

cd my-app  # Replace with your project name
npm run dev

   curl -X POST http://localhost:3000/start-app \
     -H "Content-Type: application/json" \
     -d '{"data": {"test": "value"}, "message": "Hello!"}'

💻 Dive into the Code

Want to explore multi-language workflows further? Check out additional examples and the complete source code:

Conclusion: The Power of Unification Through Steps

This multi-language data processing pipeline demonstrates how steps fundamentally change multi-language development. By providing a single primitive that works across TypeScript, Python, and JavaScript, we've eliminated the traditional complexity of polyglot architectures.

The step primitive enables true unification:

• Universal Pattern - Every step, regardless of language, follows the same receive-process-emit pattern
• Seamless Integration - Add Ruby, Go, Rust, or any language using the same step abstraction
• Unified Deployment - All languages deploy together as a single, coherent system
• Shared Development Model - Write, debug, and monitor everything through the same interface

Key benefits of step-based unification:

• Single Mental Model - Learn the step pattern once, apply it to any language
• Cohesive System - All components work together as parts of one application, not separate services
• Consistent Experience - Development, debugging, and monitoring work the same way across all languages
• Natural Scaling - Each step can scale independently while maintaining system coherence

Extend your pipeline with more steps:

• Add specialized processing steps for different data types and business logic
• Integrate machine learning workflows with Python steps for AI processing
• Build real-time analytics with streaming steps for live data processing
• Connect to enterprise systems through database and API integration steps
• Implement scheduled processing with cron steps for batch operations

The step primitive makes all extensions natural and straightforward—every new capability follows the same unified pattern.

Ready to unify your multi-language systems? Start building with steps today!