[opensourcedex]

selenium is a free, open source testing & quality assurance project written in Java and released under Apache-2.0. It has 34,499 GitHub stars, 8,718 forks and 188 open issues, and was last pushed 4 hours ago. On this registry it ranks #3 of 6 tracked projects in Testing & Quality Assurance, with 5 head-to-head comparisons available.

What is selenium?

Selenium is a browser automation framework and ecosystem — an umbrella project providing infrastructure for the W3C WebDriver specification, a platform- and language-neutral coding interface for driving all major web browsers — aimed at developers and quality engineers who automate browser behaviour from Java, .NET, JavaScript, Python, Ruby, or Rust.

What it is

Selenium is an umbrella project encapsulating a variety of tools and libraries that enable web browser automation. Its core contribution is infrastructure for the W3C WebDriver specification: a platform- and language-neutral coding interface that is compatible with all major web browsers. The project is written primarily in Java and released under the Apache-2.0 licence, and it is maintained by volunteer contributors who have donated thousands of hours to code development and upkeep.

The concrete problem it solves is uniformity. Browser automation would otherwise require separate, browser-specific control code for each engine a team needs to drive. Selenium replaces that with one WebDriver-based interface, so the same automation logic reaches every supported browser, and the same conceptual model is exposed through official bindings in several languages. The repository also carries the contributor toolchain — build configuration, CI workflows, and platform setup scripts — that produces and validates those libraries.

Key capabilities

  • Provides infrastructure for the W3C WebDriver specification, a platform- and language-neutral interface compatible with all major web browsers.
  • Ships tooling and libraries for multiple language ecosystems, reflected in its topics: dotnet, java, javascript, python, ruby, and rust, alongside selenium and webdriver.
  • Operates as an umbrella project, so browser automation tools and language bindings live under one repository rather than scattered projects.
  • Builds through Bazelisk, a Bazel wrapper that automatically downloads the Bazel version named in the .bazelversion file and transparently passes command-line arguments to the real Bazel binary.
  • Supports platform-specific build configuration, including the --host_platform=//:rosetta flag placed in .bazelrc.local for Rosetta on Apple Silicon Macs.
  • Offers a Windows bootstrap path through scripts/dev-environment-setup.ps1, which provisions a complete ready-to-execute developer environment from PowerShell.
  • Runs continuous integration through the ci.yml and ci-rbe.yml workflows, with published release downloads tracked separately.

Who uses it and how

  • Test and QA teams in polyglot organisations, who pick the binding matching their existing stack — java, python, dotnet, javascript, ruby, or rust — instead of standardising on one language.
  • Application teams automating browser behaviour against all major web browsers through a single WebDriver interface rather than per-browser control code.
  • Contributors building the project itself on macOS, where the setup requires Xcode including command-line tools, plus Rosetta configuration for Apple Silicon machines.
  • Contributors on Windows, who either run scripts/dev-environment-setup.ps1 as Administrator or install MSYS2 manually, add its bin directory to PATH, and set the BAZEL_SH variable to the location of bash.exe.
  • Maintainers and CI systems, which rely on the checked-in workflows and the pinned Bazel version to keep builds reproducible across platforms.

Getting started

End users should not start from this repository; the README directs them to the User Manual at selenium.dev/documentation for detailed examples, with support routes listed at selenium.dev/support. Contributors set up a local environment with Bazelisk and Java JDK 17 or greater — with JAVA_HOME pointing at the JDK, not the JRE — and on Windows may run scripts/dev-environment-setup.ps1 to provision everything automatically.

How it compares

No list of paid products is provided in the facts, and no comparable tools are named either, so Selenium stands alone in this registry — it is the only browser automation framework documented here, and its distinguishing trait within the available facts is that it supplies the WebDriver specification infrastructure and bindings across six language ecosystems at once. Readers looking for alternatives should note that this page makes no comparative claims beyond that.

When to use it — and when not to

A self-hoster or contributor must operate a nontrivial build environment: Bazelisk, Java JDK 17 or greater, Xcode command-line tools on macOS, MSYS2 and PowerShell execution-policy changes on Windows, and Rosetta flags on Apple Silicon. Anyone who only wants to write browser tests should not begin here, because this README is explicitly written for developers interested in contributing to the project rather than for users, and the contributor instructions are the bulk of its content. Treat the signposting to the separate User Manual as the honest limit of what this page can tell a first-time user.

project readme (upstream, from github) — read inline



Selenium

Automates browsers. That's it!

Contributing • Installing • Building • Developing • Testing • Documenting • Releasing


Selenium is an umbrella project encapsulating a variety of tools and libraries enabling web browser automation. Selenium specifically provides an infrastructure for the W3C WebDriver specification — a platform and language-neutral coding interface compatible with all major web browsers.

The project is made possible by volunteer contributors who've generously donated thousands of hours in code development and upkeep.

This README is for developers interested in contributing to the project. For people looking to get started using Selenium, please check out our User Manual for detailed examples and descriptions, and if you get stuck, there are several ways to Get Help.

CI CI - RBE Releases downloads

Contributing

Please read CONTRIBUTING.md before submitting your pull requests.

Installing

These are the requirements to create your own local dev environment to contribute to Selenium.

All Platforms

  • Bazelisk, a Bazel wrapper that automatically downloads the version of Bazel specified in .bazelversion file and transparently passes through all command-line arguments to the real Bazel binary.
  • Java JDK version 17 or greater (e.g., Java 17 Temurin)
    • Set JAVA_HOME environment variable to location of Java executable (the JDK not the JRE)
    • To test this, try running the command javac. This command won't exist if you only have the JRE installed. If you're met with a list of command-line options, you're referencing the JDK properly.

MacOS

  • Xcode including the command-line tools. Install the latest version using: xcode-select --install
  • Rosetta for Apple Silicon Macs. Add build --host_platform=//:rosetta to the .bazelrc.local file. We are working to make sure this isn't required in the long run.

Windows

Several years ago Jim Evans published a great article on Setting Up a Windows Development Environment for the Selenium .NET Language Bindings; This article is out of date, but it includes more detailed descriptions and screenshots that some people might find useful.

Click to see Current Windows Setup Requirements
Option 1: Automatic Installation from Scratch

This script will ensure a complete ready to execute developer environment. (nothing is installed or set that is already present unless otherwise prompted)

  1. Open Powershell as an Administrator
  2. Execute: Set-ExecutionPolicy Bypass -Scope Process -Force to allow running the script in the process
  3. Navigate to the directory you want to clone Selenium in, or the parent directory of an already cloned Selenium repo
  4. Download and execute this script in the powershell terminal: [scripts/dev-environment-setup.ps1]`
Option 2: Manual Installation
  1. Allow running scripts in Selenium in general:
    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
  2. Enable Developer Mode:
    reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\AppModelUnlock" /t REG_DWORD /f /v "AllowDevelopmentWithoutDevLicense" /d "1"
  3. Install MSYS2, which is an alternative shell environment that provides Unix-like commands
    • Add bin directory to PATH environment variable (e.g., "C:\tools\msys64\usr\bin")
    • Add bash.exe location as the BAZEL_SH environment variable (e.g., "C:\tools\msys64\usr\bin\bash.exe")
  4. Install the latest version of Visual Studio Community
    • Use the visual studio installer to modify and add the "Desktop development with C++" Workload
    • Add Visual C++ build tools installation directory location to BAZEL_VC environment variable (e.g. "C:\Program Files\Microsoft Visual Studio\2022\Community\VC")
    • Add Visual C++ Build tools version to BAZEL_VC_FULL_VERSION environment variable (this can be discovered from the directory name in "$BAZEL_VC\Tools\MSVC\")
  5. Add support for long file names (bazel has a lot of nested directories that can exceed default limits in Windows)
    • Enable Long Paths support with these 2 registry commands:
    reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor" /t REG_DWORD /f /v "DisableUNCCheck" /d "1"
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem" /t REG_DWORD /f /v "LongPathsEnabled" /d "1"
    • Allow Bazel to create short name versions of long file paths: fsutil 8dot3name set 0
    • Set bazel output to C:/tmp instead of nested inside project directory:
      • Create a file selenium/.bazelrc.windows.local
      • Add "startup --output_user_root=C:/tmp" to the file

Alternative Dev Environments

If you want to contribute to the project, but do not want to set up your own local dev environment, there are two alternatives available.

Using GitPod

Rather than creating your own local dev environment, GitPod provides a ready to use environment for you.

Open in Gitpod

Using Dev Container

As an alternative you can build a Dev Container - basically a docker container - suitable for building and testing Selenium using the devcontainer.json in the .devcontainer directory. Supporting IDEs like VS Code or IntelliJ IDEA should point you to how such a container can be created.

Using Docker Image

You can also build a Docker image suitable for building and testing Selenium using the Dockerfile in the dev image directory.

Using Worktrees

Bazel keeps its build outputs and downloaded dependencies under each checkout by default, which means working from multiple worktrees re-downloads dependencies and rebuilds artifacts. Pointing Bazel at user-level caches avoids that.

Add the following to /path/to/your/home/.bazelrc

common --disk_cache=/path/to/your/home/.cache/bazel-disk
common --repository_cache=/path/to/your/home/.cache/bazel-repo

--disk_cache stores compiled action outputs; --repository_cache stores downloaded external dependencies (e.g. http_archive tarballs). Both directories grow unbounded over time — prune them periodically if disk space matters. Keep the cache on the same filesystem as your checkouts so Bazel can hardlink instead of copy.

Bazel also creates a separate output base (compiled outputs, analysis cache, and the Bazel server) per checkout path. Unlike the caches above, it is not removed when you delete a worktree — so frequently created and discarded worktrees leak gigabytes of stale output.

On macOS/Linux, make a worktree self-cleaning by pointing its output base inside the worktree. Add this to that worktree's .bazelrc.local:

startup --output_base=.local/output-base

.local/ is gitignored and excluded in .bazelignore, so removing the worktree removes its output base with it. The shared --disk_cache/--repository_cache above still keep downloads and action outputs shared across worktrees.

(Windows users should instead keep startup --output_user_root=C:/tmp in .bazelrc.windows.local as described above, to avoid path-length limits — do not nest the output base deeper inside the repo on Windows.)

Building

Selenium is built using a common build tool called Bazel, to allow us to easily manage dependency downloads, generate required binaries, build and release packages, and execute tests; all in a fast, efficient manner. For

readme truncated — read the full docs on github

Frequently asked questions

Is selenium free to use?

selenium is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does selenium do?

A browser automation framework and ecosystem.

What is selenium written in?

selenium is primarily written in Java. Its source is publicly available at https://github.com/SeleniumHQ/selenium, and it has 34,499 GitHub stars.