OpenAI gym

Top Builders

Explore the top contributors showcasing the highest number of app submissions within our community.

OpenAI gym

Gym is a toolkit from OpenAI that offers a wide array of simulated environments (e.g. Atari games, board games, 2D and 3D physical simulations) for you to train agents, benchmark them, and create new Reinforcement Learning algorithms.

General
Relese date	April 27, 2016
Author	OpenAI
Repository	https://github.com/openai/gym
Type	Reinforcement Learning

Libraries

A curated list of libraries and technologies to help you play with OpenAI Gym.

Gym Library Gym is a standard API for reinforcement learning, and a diverse collection of reference environments
OpenAI Gym repository Gym is an open source Python library for developing and comparing reinforcement learning algorithms by providing a standard API to communicate between learning algorithms and environments, as well as a standard set of environments compliant with that API. Since its release, Gym's API has become the field standard for doing this.
Gymnasium Gymnasium is an open source Python library for developing and comparing reinforcement learning algorithms by providing a standard API to communicate between learning algorithms and environments, as well as a standard set of environments compliant with that API. This is a fork of OpenAI's Gym library

Edit on GitHub

OpenAI OpenAI gym AI technology Hackathon projects

Discover innovative solutions crafted with OpenAI OpenAI gym AI technology, developed by our community members during our engaging hackathons.

BlackBox - Video Captioning Agent

This project is built around the video captioning challenge: take a fixed set of short clips, thirty seconds to two minutes each, and write a caption for every one in four distinct voices. Rather than settling for one caption made safe enough for everyone, Blackbox writes four honest, independent takes on the same footage. For each clip it samples frames spread across the beginning, middle, and end, transcribes anything spoken in the audio, and then drafts all four captions at once rather than one after another, so a whole batch of clips can be worked through at the same time instead of queueing. It also checks its own work: every caption is graded against the clip for accuracy and tone before it's handed back, and anything that falls short gets quietly rewritten. Under the hood it leans on Google DeepMind's Gemma 4 as the first model to look at each clip, with Fireworks AI's minimax-m3 and qwen3p7-plus waiting as backups in case the primary model is busy or unavailable, Google Cloud Speech-to-Text for transcription, and a Dockerized Python pipeline .

ROCmPorter Agent — CUDA to ROCm

ROCmPorter Agent turns CUDA lock-in into a verifiable migration path to AMD ROCm. Most AI and HPC projects are built around NVCC, CUDA headers, nvidia/cuda containers, and CUDA-only Python wheels. Teams that want to move to AMD hardware face two problems: they can't see which files actually block the port, and they can't trust raw LLM-generated migration patches, which routinely hallucinate APIs and break builds. ROCmPorter solves both. The workflow has five reviewable steps. Scan: clone any public or private GitHub repository and detect CUDA/NVIDIA assumptions with a deterministic, evidence-driven scanner — every finding cites a concrete file and line with severity and confidence. Report: get a ROCm portability score, an executive summary, and a migration checklist. Patch: generate a single-file ROCm review artifact using local Ollama with qwen2.5-coder — no paid cloud LLM API, so private code never leaves the machine. Verify: every artifact passes syntax validation, source drift checks, diff replay, artifact hashing, and CUDA/ROCm-aware semantic risk scoring. Apply stays gated until verification returns applyReady=true — the product is honest about what AI output can and cannot be trusted to do. Export: offline HTML/JSON/Markdown bundles, checksummed zips, and GitHub-ready PR review comments with inline suggestions. The proof is tracked in the repo: benchmark run submission-proof-v2 completed 3/3 cases against real repositories (pytorch/extension-cpp, NVIDIA/cuda-samples) with 3 export-ready review artifacts, 0 failures, and 0 high-risk patches. Stack: React + Vite frontend, FastAPI backend, local Ollama. Live demo hosts the production UI — click "Load Sample Scan" for the full offline judge flow. Built by Team Hacker Is Back for the AMD Developer Hackathon ACT II, Unicorn Track.

Command - NL Control Layer for Legged Robots

Legged robots already have working motion primitives - gait controllers, RL policies, canned animations. What they don't have is a universal natural-language front end that reasons about whether a command is actually safe to run right now, given the robot's live state. Command is that layer. The same literal command, "walk forward 2 meters," produces three different outcomes depending on state: at 90% battery on flat terrain it executes in full; at 30% battery on rough terrain it's modified to a shorter, safer distance with a stated reason; at 8% battery it's refused outright, citing the failed precondition. This isn't keyword matching - we proved it live against commands a regex baseline structurally cannot solve: the model refuses "move forward until you find something weird" because the robot's capability profile has no perception primitive, plans an 8-step square from "walk a square, 1 meter each side," and computes verifiable battery-budget arithmetic for round-trip commands (confirmed by post-run telemetry matching its own math). A deterministic validation layer sits between the model and the robot: hallucinated function names, bad parameters, and preconditions that fail mid-plan are all caught before any primitive reaches the hardware. The same reasoning layer dispatches, unchanged, across a hexapod, a quadruped, and a wheeled rover with an entirely novel capability profile - proving the interface is genuinely robot-agnostic, not hardcoded per morphology. Model inference runs on AMD Instinct GPUs via the AMD Developer Cloud (ROCm), with Fireworks-on-AMD as the AMD-powered development backend - switching between them is a config change, not a code change. A live PyBullet simulation and a real physical hexapod (driven over its existing WiFi protocol, no firmware changes) both demonstrate the same validated reasoning output in motion.

ChaosMonkey MCP

ChaosMonkey MCP is a local-first MCP server for autonomous fault injection and crash discovery. It gives AI agents such as IBM Bob, Claude, Cursor, and Codex provider-agnostic chaos engineering tools that can stress-test local projects, inject failures, execute commands, and identify resilience issues automatically. The project focuses on autonomous crash discovery rather than remediation. ChaosMonkey MCP does not modify repositories or generate fixes. Instead, it helps AI agents uncover hidden failure modes such as null-handling bugs, malformed payload assumptions, weak validation, and fragile error handling. The platform currently includes: * fault injection through nested null mutation, * repeated chaos execution with deterministic seeds, * structured crash and traceback reporting, * safe local command execution, * secure local file reading, * a production-ready local FastMCP server. ChaosMonkey MCP runs entirely locally over stdio using the Model Context Protocol, without requiring any cloud backend or hosted infrastructure. The project was developed using IBM Bob IDE during the hackathon, including the MCP architecture, tool design, fault injection workflows, and crash discovery pipeline. It demonstrates how IBM Bob can be used to design AI-native developer tooling and autonomous resilience testing workflows.