Skip to content

devenvmgr/interpreters

BranchesTags

Repository files navigation

devenvmgr/interpreters

Docker Image License Alpine Linux

Universal development environment for interpreted languages and static site generators.

A comprehensive Docker-based environment that provides all major interpreted language runtimes, package managers, and static site generators in a single unified image. Perfect for polyglot development, CI/CD pipelines, and static site generation.

Architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│                       devenvmgr/interpreters                                │
│                         Alpine Linux base                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐           │
│  │  JavaScript │ │   Python    │ │    Ruby     │ │     PHP     │           │
│  │  TypeScript │ │             │ │             │ │             │           │
│  ├─────────────┤ ├─────────────┤ ├─────────────┤ ├─────────────┤           │
│  │ Node.js LTS │ │ Python 3.12 │ │ Ruby 3.3    │ │ PHP 8.3     │           │
│  │ Bun         │ │ Poetry      │ │ Bundler     │ │ Composer    │           │
│  │ Deno        │ │ pipenv      │ │ Jekyll      │ │ Laravel     │           │
│  │ npm/pnpm    │ │ Flask/Django│ │ Rails       │ │ Symfony     │           │
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘           │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐           │
│  │    Perl     │ │     Lua     │ │   Elixir    │ │   Haskell   │           │
│  │             │ │             │ │   Erlang    │ │             │           │
│  ├─────────────┤ ├─────────────┤ ├─────────────┤ ├─────────────┤           │
│  │ Perl 5.38   │ │ Lua 5.4     │ │ Elixir 1.17 │ │ GHC 9.8     │           │
│  │ CPAN        │ │ LuaRocks    │ │ Erlang 27   │ │ Cabal       │           │
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘           │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐           │
│  │   R/Julia   │ │    SSGs     │ │ Data Science│ │   Groovy    │           │
│  │             │ │             │ │             │ │   (JVM)     │           │
│  ├─────────────┤ ├─────────────┤ ├─────────────┤ ├─────────────┤           │
│  │ R 4.4       │ │ Hugo/Zola   │ │ Jupyter     │ │ Groovy 4.0  │           │
│  │ Julia 1.11  │ │ Jekyll      │ │ JupyterLab  │ │ OpenJDK 17  │           │
│  │             │ │ Eleventy    │ │ Streamlit   │ │             │           │
│  │             │ │ Hexo/Docusa.│ │             │ │             │           │
│  └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘           │
└─────────────────────────────────────────────────────────────────────────────┘

Available Images

ghcr.io/devenvmgr/interpreters:latest     # Latest build
ghcr.io/devenvmgr/interpreters:2601       # January 2026 version (YYMM format)
ghcr.io/devenvmgr/interpreters:<commit>   # Specific commit SHA

Quick Start

# Pull the image
docker pull ghcr.io/devenvmgr/interpreters:latest

# Auto-detect project and install dependencies
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest --install

# Auto-detect and start dev server
docker run --rm -v $(pwd):/workspace -p 3000:3000 \
  ghcr.io/devenvmgr/interpreters:latest --dev

# Auto-detect and build project
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest --build

# Interactive shell
docker run --rm -it -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest

# Show all available runtimes
docker run --rm ghcr.io/devenvmgr/interpreters:latest --info

Project Auto-Detection

The container automatically detects your project type and configures the appropriate runtime and package manager.

Detect Project Type

docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest --detect

# Output:
# Auto-detecting project type in: .
# ok Detected: Next.js project (npm)
#
# Project configuration:
#   Type:            nextjs
#   Runtime:         nodejs
#   Package manager: npm
#   Framework:       Next.js

Supported Project Types

Language Detection File(s) Package Managers Frameworks
Node.js package.json npm, yarn, pnpm, bun Next.js, Nuxt, Astro, Gatsby, Eleventy, VitePress, Ghost, React, Vue, Svelte, Express
Deno deno.json, deno.jsonc deno Fresh, Lume
Bun bunfig.toml bun Elysia
Python pyproject.toml, Pipfile, requirements.txt poetry, pipenv, pip, pdm Django, Flask, FastAPI, Pelican, MkDocs, Sphinx
Ruby Gemfile bundler Jekyll, Rails, Sinatra, Middleman
PHP composer.json composer Laravel, Symfony, Slim
Elixir mix.exs mix Phoenix
Haskell stack.yaml, *.cabal stack, cabal -
Julia Project.toml Pkg -
R DESCRIPTION renv -
Perl cpanfile, Makefile.PL cpanm -
Lua *.rockspec luarocks -
Hugo hugo.toml, hugo.yaml hugo -

Included Runtimes

JavaScript / TypeScript

Runtime Version Description
Node.js LTS JavaScript runtime
npm Latest Node package manager
pnpm Latest Fast, disk-efficient package manager
yarn Latest Alternative package manager
Bun Latest Fast JavaScript runtime & bundler
Deno Latest Secure TypeScript runtime

Python

Tool Version Description
Python 3.12 Python interpreter
pip Latest Package installer
Poetry Latest Dependency management
pipenv Latest Virtual environments
PDM Latest Modern package manager

Ruby

Tool Version Description
Ruby 3.3 Ruby interpreter
gem Latest RubyGems
Bundler Latest Dependency management
Jekyll Latest Static site generator

PHP

Tool Version Description
PHP 8.3 PHP interpreter
Composer Latest Dependency management

Other Languages

Language Version Tools
Perl 5.38 cpanm
Lua 5.4 LuaRocks
R 4.4 tidyverse
Julia 1.11 Pkg
Elixir 1.17 Mix, Erlang 27
Haskell GHC 9.8 Cabal
Groovy 4.0 OpenJDK 17

Static Site Generators & CMS

SSG/CMS Language Description
Hugo Go Fast, flexible
Zola Rust Single-binary, fast
Jekyll Ruby GitHub Pages compatible
Eleventy Node.js Simple, powerful
Hexo Node.js Fast blogging framework
Docusaurus Node.js Documentation sites
Astro Node.js Modern, islands architecture
Gatsby Node.js React-based
VitePress Node.js Vue-powered docs
Ghost Node.js Professional publishing platform
MkDocs Python Documentation focused
Pelican Python Python blogs

Data Science & Notebooks

Tool Description
Jupyter Interactive notebooks
JupyterLab Next-gen notebook interface
Streamlit Data apps and dashboards

Usage Examples

Node.js / Next.js

# Install dependencies and start dev server
docker run --rm -v $(pwd):/workspace -p 3000:3000 \
  ghcr.io/devenvmgr/interpreters:latest bash -c '
    npm install
    npm run dev
  '

# Or use auto-detection
docker run --rm -v $(pwd):/workspace -p 3000:3000 \
  ghcr.io/devenvmgr/interpreters:latest --dev

Python / Django

# Install and run Django
docker run --rm -v $(pwd):/workspace -p 8000:8000 \
  ghcr.io/devenvmgr/interpreters:latest bash -c '
    pip install -r requirements.txt
    python manage.py runserver 0.0.0.0:8000
  '

Ruby / Jekyll (GitHub Pages)

# Build Jekyll site
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest bash -c '
    bundle install
    bundle exec jekyll build
  '

# Serve locally
docker run --rm -v $(pwd):/workspace -p 4000:4000 \
  ghcr.io/devenvmgr/interpreters:latest bash -c '
    bundle install
    bundle exec jekyll serve --host 0.0.0.0
  '

Hugo Static Site

# Build Hugo site
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest hugo --minify

# Serve locally
docker run --rm -v $(pwd):/workspace -p 1313:1313 \
  ghcr.io/devenvmgr/interpreters:latest hugo server --bind 0.0.0.0

Ghost CMS

# Install Ghost in current directory
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest ghost install local

# Start Ghost
docker run --rm -v $(pwd):/workspace -p 2368:2368 \
  ghcr.io/devenvmgr/interpreters:latest ghost start

# Or use auto-detection if Ghost is already installed
docker run --rm -v $(pwd):/workspace -p 2368:2368 \
  ghcr.io/devenvmgr/interpreters:latest --dev

Python MkDocs Documentation

# Build docs
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest mkdocs build

# Serve locally
docker run --rm -v $(pwd):/workspace -p 8000:8000 \
  ghcr.io/devenvmgr/interpreters:latest mkdocs serve -a 0.0.0.0:8000

Zola Static Site

# Build Zola site
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest zola build

# Serve locally
docker run --rm -v $(pwd):/workspace -p 1111:1111 \
  ghcr.io/devenvmgr/interpreters:latest zola serve --interface 0.0.0.0

Hexo Blog

# Create new Hexo blog
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest hexo init my-blog

# Generate and serve
docker run --rm -v $(pwd):/workspace -p 4000:4000 \
  ghcr.io/devenvmgr/interpreters:latest bash -c '
    cd my-blog && npm install
    hexo generate
    hexo server -p 4000
  '

Docusaurus Documentation

# Create new Docusaurus site
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest npx create-docusaurus@latest my-docs classic

# Serve locally
docker run --rm -v $(pwd):/workspace -p 3000:3000 \
  ghcr.io/devenvmgr/interpreters:latest bash -c '
    cd my-docs && npm install
    npm start -- --host 0.0.0.0
  '

Jupyter Notebooks

# Start JupyterLab
docker run --rm -v $(pwd):/workspace -p 8888:8888 \
  ghcr.io/devenvmgr/interpreters:latest \
  jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root

# Start classic Jupyter Notebook
docker run --rm -v $(pwd):/workspace -p 8888:8888 \
  ghcr.io/devenvmgr/interpreters:latest \
  jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root

Streamlit Data Apps

# Run Streamlit app
docker run --rm -v $(pwd):/workspace -p 8501:8501 \
  ghcr.io/devenvmgr/interpreters:latest \
  streamlit run app.py --server.address 0.0.0.0

Groovy Scripts

# Run Groovy script
docker run --rm -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest groovy script.groovy

# Interactive Groovy shell
docker run --rm -it -v $(pwd):/workspace \
  ghcr.io/devenvmgr/interpreters:latest groovysh

GitHub Actions Integration

jobs:
  build:
    runs-on: ubuntu-latest
    container: ghcr.io/devenvmgr/interpreters:latest

    steps:
      - uses: actions/checkout@v4

      - name: Install dependencies
        run: |
          # Auto-detect and install
          /usr/local/bin/entrypoint.sh --install

      - name: Build
        run: |
          # Auto-detect and build
          /usr/local/bin/entrypoint.sh --build

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: build-output
          path: dist/  # or _site/, public/, etc.

Multi-Framework Matrix

strategy:
  matrix:
    include:
      - project: nextjs-app
        port: 3000
      - project: jekyll-site
        port: 4000
      - project: hugo-blog
        port: 1313

steps:
  - name: Build ${{ matrix.project }}
    working-directory: ${{ matrix.project }}
    run: |
      /usr/local/bin/entrypoint.sh --install
      /usr/local/bin/entrypoint.sh --build

VS Code Dev Container

Add to your project's .devcontainer/devcontainer.json:

{
    "name": "Interpreters Environment",
    "image": "ghcr.io/devenvmgr/interpreters:latest",
    "forwardPorts": [3000, 4000, 5000, 8000],
    "postCreateCommand": "interpreters-info"
}

Environment Variables

Variable Default Description
NODE_ENV development Node.js environment
PYTHONDONTWRITEBYTECODE 1 Don't create .pyc files
PYTHONUNBUFFERED 1 Unbuffered Python output
GEM_HOME /usr/local/bundle Ruby gem installation path
COMPOSER_HOME /root/.composer Composer home directory
MIX_ENV dev Elixir environment

Comparison with binmgr/toolchain

Feature devenvmgr/interpreters binmgr/toolchain
Purpose Interpreted languages & SSGs Static binary compilation
Languages Node.js, Python, Ruby, PHP, Groovy, etc. C, C++, Rust, Go, Zig, Dart
Output Scripts, bundles, HTML, notebooks Static executables
Use cases Web dev, CI/CD, docs, data science CLI tools, system utilities
Cross-compile No Yes (20+ targets)

Use binmgr/toolchain for building portable static binaries. Use devenvmgr/interpreters for interpreted language development and static site generation.

Contributing

  1. Fork the repository
  2. Create a feature branch
  3. Test your changes: make build-test
  4. Submit a pull request

License

MIT License - see LICENSE.md for details.

Built for polyglot developers and static site enthusiasts

GitHub Docker

About

Repo for interpreters

github.com/devenvmgr/interpreters

Resources

Readme

License

MIT license
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages