What Programming Languages Are Supported for OpenAI Plugins?

OpenAI plugins are language-agnostic—any programming language that can expose an HTTP endpoint or provide a callable SDK can be used, with official examples in Python, JavaScript/Node.js, TypeScript, Go, Ruby, Swift, Java, C++, C#, and Rust.

The openai/plugins repository demonstrates production-grade implementations across multiple technology stacks. Because the platform communicates via HTTP and manifest files rather than language-specific bindings, you can build plugins using whatever runtime best fits your product architecture.

Languages Demonstrated in the Official Repository

The openai/plugins repository contains concrete examples spanning ten distinct programming languages. Each implementation validates that the platform's architecture imposes no language restrictions.

Python

Python appears extensively throughout the codebase, particularly in helper scripts and automation tools. The Zotero plugin provides a canonical example in plugins/zotero/skills/zotero/scripts/zotero.py, which implements a simple CLI dispatcher that returns JSON responses based on command-line arguments.

JavaScript and Node.js

Node.js powers numerous webhook integrations and serverless functions. The Zoom plugin includes Node.js webhook handlers documented in plugins/zoom/skills/webhooks/references/full-guide.md, demonstrating how to receive and process events using Express.js.

TypeScript

Modern frontend frameworks ship with TypeScript by default in this ecosystem. The Vercel plugin showcases TypeScript-heavy implementations in plugins/vercel/skills/nextjs/SKILL.md, including Next.js applications that integrate directly with the Codex UI.

Go

Go appears in Vercel service implementations and select Zoom SDK samples. The Vercel services documentation in plugins/vercel/skills/vercel-services/SKILL.md explicitly mentions Go as a supported runtime for backend functions.

Ruby

Ruby support is documented within the Vercel functions skill at plugins/vercel/skills/vercel-functions/SKILL.md, which lists Ruby as a first-class runtime for serverless deployment.

Swift

iOS and macOS development leverage Swift exclusively. The build-ios-apps plugin contains SwiftUI-centric configurations in plugins/build-ios-apps/.codex-plugin/plugin.json, targeting native Apple platform development.

Java

Android SDK implementations utilize Java. The Zoom plugin provides Android-specific guidance in plugins/zoom/skills/video-sdk/android/SKILL.md, covering Java-based integration patterns for mobile devices.

C++ and C#

Desktop SDKs for Windows and Linux utilize C++ and C# (.NET). The Zoom meeting SDK documentation in plugins/zoom/skills/meeting-sdk/windows/SKILL.md and video SDK references in plugins/zoom/skills/video-sdk/windows/SKILL.md establish C++ and .NET as supported environments for native desktop applications.

Rust and Shell

Rust appears as a runtime-installable package option in plugins/ngs-analysis/.codex-plugin/plugin.json, while Bash and shell scripts handle CLI tooling and automation workflows throughout the repository, including the plugin scaffolding utility at plugins/.agents/skills/plugin-creator/scripts/create_basic_plugin.py.

How the Architecture Enables Language Agnosticism

The plugin framework achieves language independence through four architectural layers that abstract away implementation details.

Manifest-based configuration – Each plugin defines itself via .codex-plugin/plugin.json, which specifies metadata, skills, and interfaces without referencing specific languages. This JSON structure allows any executable to register as a plugin component.

Skill abstraction – Skills may be Python scripts, WebAssembly modules, compiled binaries, or serverless functions. The platform invokes these via HTTP or CLI protocols, making the underlying runtime irrelevant to the orchestration layer.

Runtime-installable packages – Advanced plugins declare dependencies that can pull in language runtimes on-demand. This approach, seen in the NG-S analysis plugin, allows Python, Go, or other environments to be provisioned dynamically without requiring host-system prerequisites.

MCP surfaces – Model-Context-Protocol surfaces for frontend UI components (such as Vercel's Next.js or SvelteKit implementations) communicate with backends via HTTP, decoupling the TypeScript frontend from whatever language powers the API.

Code Examples by Language

Python Skill Implementation

The Zotero plugin demonstrates a minimal Python entry point that processes CLI arguments and returns JSON:

# plugins/zotero/skills/zotero/scripts/zotero.py

#!/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

The Zoom plugin provides a TypeScript-compatible Node.js example for handling HTTP webhooks:

// plugins/zoom/skills/webhooks/server.ts
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 iOS Plugin Manifest

The iOS builder plugin configures Swift-based development through its manifest file:

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

This configuration resides in plugins/build-ios-apps/.codex-plugin/plugin.json.

Summary

• OpenAI plugins support any language capable of exposing an HTTP endpoint or callable binary.
• The official repository provides reference implementations in Python, JavaScript/Node.js, TypeScript, Go, Ruby, Swift, Java, C++, C#, and Rust.
• Language agnosticism is achieved through manifest-based configuration (.codex-plugin/plugin.json), skill abstraction, and HTTP-based communication.
• Skills can be scripts, compiled binaries, or serverless functions without platform-level restrictions.
• Frontend surfaces typically use TypeScript (Next.js, Astro, SvelteKit) while backends remain language-flexible.

Frequently Asked Questions

Can I use any programming language to build an OpenAI plugin?

Yes. The platform does not restrict you to specific languages. As long as your code can expose an HTTP endpoint or accept CLI invocations, it can function as a plugin. The repository demonstrates this flexibility through working examples in Python, Go, Swift, C++, and others.

Do I need to use Python for OpenAI plugin development?

No. While Python appears frequently in automation scripts and helper utilities within the repository, it is not required. The plugins/zotero/skills/zotero/scripts/zotero.py file shows one approach, but equivalent functionality can be implemented in Node.js, Go, or any other language.

How does the plugin system handle different runtime environments?

The system uses runtime-installable packages and containerized execution. Plugins declare their dependencies in manifests, allowing the platform to provision appropriate interpreters (Python, Ruby, Node.js) or compile binaries (Go, Rust, C++) on-demand. This eliminates the need for universal host-system support.

Are there performance considerations when choosing a language for OpenAI plugins?

Performance depends on your specific use case rather than platform constraints. HTTP-based skills perform similarly regardless of implementation language, while CLI-based skills may show variance in cold-start times. Compiled languages like Go or Rust may offer faster startup for command-line tools, whereas Python provides rapid development for data-processing tasks.

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