What Programming Languages Are Used in OpenMetadata? A Complete Technical Breakdown

OpenMetadata is built with four primary programming languages: Java 21 for backend services, Python 3.10-3.12 for metadata ingestion, TypeScript with React for the frontend UI, and Bash with Docker for deployment automation.

Understanding what programming languages are used in OpenMetadata helps developers, contributors, and platform teams quickly orient themselves within this unified metadata platform. As a polyglot project, OpenMetadata strategically selects each language based on the specific demands of its architectural layer—performance for the backend, flexibility for connectors, and type safety for the user interface.

Backend Services: Java 21 with Maven

The core metadata server and microservices architecture rely on Java 21 as the primary language. OpenMetadata uses the Dropwizard framework alongside JDBI3 and other mature Java libraries to deliver RESTful APIs and database connectivity.

The Java version and build configuration are explicitly declared in the root pom.xml:

<!-- From /pom.xml -->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.11.0</version>
  <configuration>
    <source>21</source>
    <target>21</target>
  </configuration>
</plugin>

Key architectural components implemented in Java include:

• Entity resource classes (e.g., HealthResource.java) exposing REST endpoints
• DAO layers using JDBI3 for database abstraction
• Authentication and authorization services with JWT and OAuth2 support
• Search indexing integration with Elasticsearch

Ingestion Framework: Python 3.10-3.12 with Pydantic

Metadata connectors and data pipelines are authored in Python 3.10 through 3.12, leveraging Pydantic 2.x for data validation and configuration management. This language choice capitalizes on Python's extensive data engineering ecosystem—libraries like SQLAlchemy, pandas, and requests enable rapid connector development against hundreds of external systems.

The ingestion framework follows a standardized plugin architecture defined in metadata.ingestion.api.source. A typical connector instantiation appears in test utilities:

# From /ingestion/tests/utils/sqa.py

from metadata.ingestion.api.source import Source
from metadata.ingestion.source.database.mysql.metadata import MySQLSource

source = MySQLSource.create(
    config={
        "username": "admin",
        "password": "secret",
        "hostPort": "localhost:3306"
    }
)

Python's role in OpenMetadata extends to:

• 90+ source connectors for databases, warehouses, BI tools, and messaging systems
• Lineage extraction and profiling workflows
• Orchestration via Apache Airflow or OpenMetadata's native scheduler
• Testing infrastructure with pytest across ingestion/tests/

Frontend UI: TypeScript and TSX with React

The web application is a React single-page application written in TypeScript (.ts and .tsx files). TypeScript provides static type checking that scales across the component hierarchy, while JSX/TSX syntax enables declarative UI construction.

Utility functions and React hooks throughout the codebase demonstrate consistent TypeScript patterns. For example, date formatting in formUtils.tsx:

// From /openmetadata-ui/src/main/resources/ui/src/utils/formUtils.tsx
export const formatDate = (date: string): string =>
  new Intl.DateTimeFormat('en-US', {
    year: 'numeric',
    month: 'short',
    day: 'numeric',
  }).format(new Date(date));

The frontend technology stack includes:

• React 18 with functional components and hooks
• Redux Toolkit for global state management
• React Router for client-side navigation
• Ant Design and custom components for the design system
• Jest and React Testing Library for unit tests

Package dependencies are declared in openmetadata-ui/src/main/resources/ui/package.json, which coordinates the Node.js build pipeline.

Deployment and Infrastructure: Bash, Docker, and YAML

Supporting automation relies on shell scripting (Bash), Dockerfile definitions, and YAML configuration for CI/CD and container orchestration. While not application logic, these languages are essential for building, testing, and deploying OpenMetadata.

The entry point script bin/openmetadata.sh demonstrates how Java and Docker workflows are orchestrated:

#!/usr/bin/env bash

# From /bin/openmetadata.sh

./mvnw clean install -DskipTests
docker-compose -f docker/docker-compose.yml up -d

Infrastructure-as-code patterns appear throughout:

• GitHub Actions workflows in .github/workflows/ for automated testing and releases
• Helm charts for Kubernetes deployment
• Docker Compose files for local development stacks
• Environment configuration under conf/ for service tuning

Summary

OpenMetadata's polyglot architecture strategically assigns programming languages to architectural layers:

• Java 21 powers the scalable backend services with Dropwizard and JDBI3
• Python 3.10-3.12 drives the flexible ingestion framework with Pydantic 2.x
• TypeScript/TSX builds the type-safe React frontend UI
• Bash, Docker, and YAML automate deployment and infrastructure management

This language selection ensures that each component of the unified metadata platform is built with tools optimized for its specific requirements—performance, ecosystem richness, or developer experience.

Frequently Asked Questions

Is Java required to run OpenMetadata?

Java 21 is required to build and run the backend metadata server, as the core services are implemented in Java using the Dropwizard framework. Pre-built Docker images include the Java runtime, so end users deploying via containers do not need to install Java separately.

Can I write custom metadata connectors in a language other than Python?

The official OpenMetadata ingestion framework is built on Python 3.10-3.12 with Pydantic 2.x, and all 90+ source connectors follow this standard. While you could theoretically build external metadata extraction in another language, integration with OpenMetadata's lineage, profiling, and scheduler requires adherence to the Python-based SDK.

What version of TypeScript does the OpenMetadata UI use?

The React frontend uses TypeScript with strict configuration settings defined in openmetadata-ui/src/main/resources/ui/tsconfig.json. The project typically tracks current TypeScript stable versions compatible with React 18 and the associated tooling ecosystem (Redux Toolkit, React Router, Jest).

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