# What Programming Languages Are Supported for OpenAI Plugins?

> Discover the programming languages supported for OpenAI plugins. Learn how you can leverage your existing skills with Python, JavaScript, Go, and more to build powerful plugins.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: faq
- Published: 2026-06-25

---

**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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/plugins/zoom/skills/meeting-sdk/windows/SKILL.md) and video SDK references in [`plugins/zoom/skills/video-sdk/windows/SKILL.md`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/.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:

```python

# 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:

```typescript
// 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:

```json
{
  "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`](https://github.com/openai/plugins/blob/main/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`](https://github.com/openai/plugins/blob/main/.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`](https://github.com/openai/plugins/blob/main/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.