What Programming Languages Are Supported for OpenAI Plugin Development?

OpenAI plugin development is language-agnostic, supporting Python, JavaScript/Node.js, TypeScript, Go, Ruby, Swift, Java, C++, C#, and any language capable of exposing an HTTP endpoint or callable binary.

The official openai/plugins repository demonstrates that the platform imposes no language restrictions. Whether you are building HTTP services, native mobile applications, or command-line utilities, OpenAI plugin development accommodates your existing tech stack through a manifest-based architecture that delegates execution to any reachable runtime.

Officially Demonstrated Languages

The repository contains production-grade examples spanning multiple language ecosystems. You are not limited to a single stack; the platform delegates to whatever executable you define in your plugin manifest.

Python

Python serves as a primary language for helper scripts and backend services. The Zotero integration in plugins/zotero/skills/zotero/scripts/zotero.py provides a concrete example of a Python-based skill that processes CLI arguments and returns JSON responses. This pattern applies to any Python script that exposes a command-line interface or HTTP server.

JavaScript and Node.js

JavaScript and Node.js power numerous webhook handlers and serverless functions. The Zoom plugin includes Node.js webhook samples documented in plugins/zoom/skills/webhooks/references/full-guide.md, demonstrating how to handle event-driven HTTP requests. These examples typically use Express.js or similar frameworks to expose endpoints that the plugin system invokes.

TypeScript

TypeScript dominates the frontend and full-stack examples, particularly within the Vercel ecosystem. The Next.js skill in plugins/vercel/skills/nextjs/SKILL.md showcases type-safe integration with the Codex UI. While the frontend uses TypeScript, the backing services can remain language-agnostic, communicating via HTTP.

Go and Ruby

The Vercel services plugin in plugins/vercel/skills/vercel-services/SKILL.md explicitly lists Go as a supported serverless runtime. Similarly, plugins/vercel/skills/vercel-functions/SKILL.md confirms Ruby as a first-class runtime for Vercel functions, proving that compiled and interpreted languages coexist within the plugin ecosystem.

Swift, Java, C++, and C#

For native mobile and desktop development, the repository includes platform-specific SDKs:

• Swift: The build-ios-apps plugin in plugins/build-ios-apps/.codex-plugin/plugin.json focuses on SwiftUI and AppKit development for iOS and macOS.
• Java: Android SDK samples reside in plugins/zoom/skills/video-sdk/android/SKILL.md, providing Java-based mobile integration patterns.
• C++ and C# (.NET): Desktop Zoom SDKs for Windows use C++ (plugins/zoom/skills/meeting-sdk/windows/SKILL.md) and .NET (plugins/zoom/skills/video-sdk/windows/SKILL.md), supporting native Windows application development.

Rust and Shell

Rust appears as a runtime-installable package in the NG-S analysis plugin configuration at plugins/ngs-analysis/.codex-plugin/plugin.json. Additionally, Shell/Bash scripts handle automation and utility tasks throughout the repository, including the plugin scaffolding tool at plugins/.agents/skills/plugin-creator/scripts/create_basic_plugin.py.

How the Architecture Enables Language Agnosticism

The plugin system achieves language flexibility through three core architectural decisions that decouple the platform from any specific runtime.

The Manifest System

Each plugin defines a plugin.json manifest located in .codex-plugin/. This file describes the plugin's name, description, assets, and skill locations without prescribing implementation languages. The manifest treats skills as black boxes; it only needs to know how to invoke them, not how they are written.

Skills as HTTP Endpoints or Binaries

A skill may be a Python script, a Node.js server, a compiled Go binary, or a WebAssembly module. The Zoom plugin exemplifies this by providing both Python helpers and Node.js webhook handlers in the same repository. As long as the skill exposes an HTTP endpoint or executable interface, the platform can dispatch requests to it.

Runtime-Installable Packages

Some plugins declare "runtime-installable" dependencies, allowing them to pull in language runtimes on-the-fly. The NG-S analysis plugin references this capability in its manifest, enabling dynamic installation of Python, Go, or other runtimes as needed. This keeps the core platform lean while supporting polyglot development.

Implementation Examples by Language

Below are concrete code snippets from the repository demonstrating how different languages implement plugin skills.

Python Skill Example

This minimal Python helper from plugins/zotero/skills/zotero/scripts/zotero.py exposes a CLI dispatcher that returns JSON based on command arguments:

#!/usr/bin/env python3
import sys, json

def main():
    # Very simple dispatcher based on the first CLI arg

    cmd = sys.argv[1] if len(sys.argv) > 1 else "status"
    if cmd == "status":
        print(json.dumps({"ready": True}))
    else:
        print(json.dumps({"error": "unknown command"}))

if __name__ == "__main__":
    main()

Node.js Webhook Handler

This TypeScript/Node.js example from plugins/zoom/skills/webhooks/references/full-guide.md creates an HTTP server to process Zoom events:

import express from "express";

const app = express();
app.use(express.json());

app.post("/zoom/webhook", (req, res) => {
  console.log("Zoom event:", req.body);
  res.sendStatus(200);
});

app.listen(3000, () => console.log("Webhook listening on 3000"));

Swift Plugin Manifest

The iOS builder plugin in plugins/build-ios-apps/.codex-plugin/plugin.json demonstrates how Swift-centric mobile apps are declared:

{
  "name": "build-ios-apps",
  "description": "SwiftUI iOS app scaffolding",
  "apps": "./.app.json",
  "skills": "./skills/",
  "interface": {
    "displayName": "iOS Builder",
    "category": "Productivity"
  }
}

Summary

• OpenAI plugin development supports any language that exposes an HTTP endpoint or callable binary, including Python, JavaScript/Node.js, TypeScript, Go, Ruby, Swift, Java, C++, and C#.
• The .codex-plugin/plugin.json manifest enforces no language constraints; it delegates execution to whatever runtime you define.
• Skills can be scripts, compiled binaries, or web servers, as demonstrated by the Zotero Python helpers and Zoom Node.js webhooks.
• Mobile and desktop development uses native languages like Swift (iOS), Java (Android), and C++ (Windows), while web services leverage JavaScript/TypeScript and Python.
• The create_basic_plugin.py scaffolding tool generates language-agnostic plugin templates, confirming the platform's polyglot design.

Frequently Asked Questions

Can I use any programming language for OpenAI plugin development?

Yes. The platform is language-agnostic as long as your code can expose an HTTP endpoint or provide a callable binary. The manifest file (plugin.json) does not enforce specific languages, allowing you to use Rust, PHP, Kotlin, or any other runtime.

What is the minimum requirement to create a plugin in my preferred language?

Your implementation must expose an HTTP service or executable script that the plugin system can invoke. The repository shows examples ranging from Python CLI tools in plugins/zotero/skills/zotero/scripts/zotero.py to C++ desktop applications in plugins/zoom/skills/meeting-sdk/windows/SKILL.md.

Does OpenAI prefer TypeScript over JavaScript for web plugins?

No. While the repository includes extensive TypeScript examples for modern frameworks like Next.js in plugins/vercel/skills/nextjs/SKILL.md, JavaScript/Node.js remains fully supported, as demonstrated by the Zoom webhook samples in plugins/zoom/skills/webhooks/references/full-guide.md.

Can I build mobile plugins using native languages like Swift or Java?

Yes. The repository includes native Swift plugins for iOS in plugins/build-ios-apps/.codex-plugin/plugin.json and Java Android SDK examples in plugins/zoom/skills/video-sdk/android/SKILL.md, allowing full native mobile integration without wrapper frameworks.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}