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

> Discover the programming languages powering OpenMetadata: Java for backend, Python for ingestion, TypeScript/React for UI, and Bash/Docker for deployment. Get the full technical breakdown.

- Repository: [OpenMetadata/OpenMetadata](https://github.com/open-metadata/OpenMetadata)
- Tags: deep-dive
- Published: 2026-04-23

---

**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`](https://github.com/open-metadata/OpenMetadata/blob/main/pom.xml):

```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`](https://github.com/open-metadata/OpenMetadata/blob/main/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:

```python

# 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`](https://github.com/open-metadata/OpenMetadata/blob/main/formUtils.tsx):

```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`](https://github.com/open-metadata/OpenMetadata/blob/main/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`](https://github.com/open-metadata/OpenMetadata/blob/main/bin/openmetadata.sh) demonstrates how Java and Docker workflows are orchestrated:

```bash
#!/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`](https://github.com/open-metadata/OpenMetadata/blob/main/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).