Open-source project
theforeman/foreman avatar
theforeman/foreman

Foreman's README has no install command, an empty screenshots section, and a name collision

an application that automates the lifecycle of servers

3,000 stars1,064 forksRubyGPL-3.0

At a glance

What is it?
A Ruby application that automates the server lifecycle, with a web frontend, CLI and REST API, and plugins packaged as Rails engines. Installation lives entirely in the manual, the npm manifest disclaims being a module, and three of its scripts call a binary it never declares.
Who is it for?
Foreman fits an organisation that provisions and manages hosts at volume across bare metal, private cloud and public cloud, and wants one place holding the inventory, the change history and the audit trail. Three things to settle first.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Yes. The repository last received commits 3 days ago.
What is it written in?
Mainly Ruby, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • theforeman/foreman3,000 ★ · +71
Star history
Repository2026-09-242026-11-15
theforeman/foreman2.9k3k

71 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Installation is delegated to the manual, and the screenshots section is empty

The Installation heading is two sentences long and contains no command. It sends the reader to the quickstart section of the manual, then to the installation scenarios section if the setup has specific needs. That is the whole of it, so an evaluation of Foreman from this repository alone is not possible; the packaged artifacts are documented elsewhere.

The Screenshots heading has nothing under it. The heading exists in the README and the content following it is empty, which is the kind of gap that survives because the section is invisible in rendered output.

Release history is absent too. The repository has no GitHub releases, and the default branch is `develop` rather than a release branch, while the coveralls badge in the README is pinned to that branch with a query parameter. The version itself lives in a `VERSION` file at the root, with packaging split across `Rakefile`, `Rakefile.dist`, `package-exclude.json` and `bundler.d/`.

The licensing section carries one detail worth quoting precisely: the repository and package are licensed under the GNU GPL v3 or newer, with some exceptions. The license field recorded for the repository is GPL-3.0, and the copyright line reads 2009-2020 for Ohad Levy, Paul Kelly and their respective owners, a range that ended six years before the last push to the branch.

A three-line section exists to send you to the Ruby CLI of the same name

The README has a heading titled similarly named project, and it exists because the collision is real. It points at a different GitHub repository also called `foreman`, described as a CLI tool for running processes, and says the note was left there to help people in case that is the one they were looking for but ended up here.

That is the whole section, three sentences, and it is doing real work. The name is a common English word, there is a well known Ruby gem with the same name doing something unrelated, and the search results for the bare word are dominated by a person and a grill appliance rather than by infrastructure software. The repository's own description field is correspondingly plain: an application that automates the lifecycle of servers, in lowercase, with no project name in it.

For anyone evaluating the project, that is the first practical obstacle and the README acknowledges it rather than hoping it goes away.

Contributions need a Redmine issue and a pass through Jenkins

The contribution section routes work through three systems that are not GitHub. The rules ask for the commit message style to be followed and a Redmine issue to be created, with the stated reason that doing it right helps reviewers merge the change faster. The issue tracker is Redmine, at projects.theforeman.org, and so is the wiki. Continuous integration is Jenkins, at ci.theforeman.org, and every pull request runs the full test suite there. Pull requests are also expected to include tests for any functional change.

Local checks are named with commands: Rubocop analyses the code and can be run with `rake rubocop`. A development handbook exists for how developers are expected to code, and `CONTRIBUTING.md` sits in the repository root for more detail.

The configuration files show what those checks are made of. There are two Rubocop files, `.rubocop.yml` and `.rubocop_todo.yml`, and the second is the standard way to record offences you have accepted for now rather than fixed. Alongside them sit `.gitleaks.toml` for secret scanning, `.stylelintrc.json` with an `.stylelintignore`, `.eslintrc.js` with `.babelrc.js`, `babel.config.js` and `.prettierrc`, and a `.tx/` directory for translation management.

The npm manifest says it is not a node module, and three scripts call an undeclared binary

package.json is named `TheForemanDevDeps`, carries version 5.1.0, is marked private, and its description states the position directly: Foreman isn't really a node module, these are just dependencies needed to build the webpack bundle, with dependencies holding the asset libraries in use and devDependencies holding what the build process needs.

That version number is the dev-dependency package's, not Foreman's, which is exactly the confusion the description exists to prevent.

The engines field is narrow: node from 22.0.0 to below 23.0.0, and npm from 8.0.0. So a machine on node 24 will not run the asset build.

Three scripts call a binary that this package does not declare. `test:watch` and `test:current` both invoke `tfm-test`, and `publish-coverage` invokes `tfm-publish-coverage`. Neither name appears in the dependency lists shown here, so they must come from a tool installed outside the package, which means a fresh clone with the declared dependencies alone cannot run those three scripts. The `postinstall` hook then runs a plugin install script, so installing the frontend dependencies triggers work across plugins.

Patternfly, Apollo, noVNC and module federation in one bundle

The dependency list explains what the frontend is. The Patternfly family is the design system, with `patternfly` itself at 5.4.2 and matching react-core, react-table, react-charts, react-icons and react-styles packages. Apollo client is the GraphQL layer. `@novnc/novnc` is pinned to exactly 1.3.0, which is the in-browser remote console.

The one that carries architectural weight is `@module-federation/utilities`. Module federation is how separately built bundles share components at runtime, and in this project it is the mechanism by which a plugin's frontend code ends up inside the host application's bundle. That is consistent with the plugin tooling elsewhere in the scripts, where lint, test and stylelint each have a separate plugin variant driven by a shell script.

It also explains why the frontend build is a repository concern rather than a plugin concern. The core declares the shared modules, the plugins consume them, and the manifest's own description says the dependencies exist to build the webpack bundle. Anything a plugin brings has to fit that arrangement.

The `webpack/` directory at the root holds the bundle configuration, including the jest config that the test script points at, and `babel.config.js` and `.babelrc.js` sit alongside each other as the two Babel configuration files.

The compose file carries default credentials and separates two Redis roles

docker-compose.yml describes four services with a fifth as an anchor. The database is `postgres:12` with the user, the password and the database name all set to `foreman`, a healthcheck on port 5432, and a random host port. The application connects with `DATABASE_URL=postgres://foreman:foreman@db/foreman?pool=5`, so the same default password appears twice in the file.

The application environment sets `RAILS_ENV=production`, `FOREMAN_FQDN=foreman.example.com` and `FOREMAN_DOMAIN=example.com`, runs against the `quay.io/foreman/foreman:develop` image, and publishes port 3000 plus the range 5910 to 5930, which is the remote console range. Two Redis services are started with different jobs: one for the Rails cache store and one for tasks, with `REDIS_PROVIDER` pointing the task framework at the second.

Orchestration and worker processes differ only in their sidekiq configuration:

yaml
  orchestrator:
    <<: *app_base
    command: bundle exec sidekiq -r ./extras/dynflow-sidekiq.rb -c 1 -q dynflow_orchestrator
    hostname: orchestrator.example.com
    ports: []

  worker:
    <<: *app_base
    command: bundle exec sidekiq -r ./extras/dynflow-sidekiq.rb -c 15 -q default,1 -q remote_execution,1
    ports: []

One orchestrator thread on the dynflow queue against fifteen worker threads spread over the default and remote execution queues, both pointing at the same extras file. The example.com hostnames and the develop image tag mark this as a development arrangement, though nothing in the file says so.

The image is CentOS Stream 9, runs as uid 1001, and deletes .c and .o after installing

The Dockerfile opens on `quay.io/centos/centos:stream9` with a Node major passed in as a build argument and enabled through dnf modules, so node 22 comes from the distribution's module stream rather than from a Node source build. The base layer runs `dnf upgrade -y` on every build, which means the base is not pinned to a fixed set of packages.

The application user is created with uid 1001, a group with gid 0, and `/sbin/nologin` as the shell, and the home directory is given group write access. An entrypoint script is copied in from `extras/containers/entrypoint.sh`.

The builder stage names the bundler groups it skips: test, development, openid, libvirt, journald, facter and console. That list is the practical statement of what the image does not contain, which is worth reading before assuming a Facter or libvirt backed host is supported by the container. Bundler is configured to install into `vendor` with five parallel jobs and three retries, then binstubs are generated, the cached gem files are removed, and every `.c` and `.o` file under the installed gems is deleted, which is a layer size optimisation that makes the image impossible to debug at the native extension level. A final step builds the locale files.

The database in the compose file is `postgres:12` while the application base is a Stream 9 image, so the two halves of the development stack come from different distribution generations.

Editorial conclusion

Foreman fits an organisation that provisions and manages hosts at volume across bare metal, private cloud and public cloud, and wants one place holding the inventory, the change history and the audit trail. Three things to settle first. There is no release history on the repository and no install command in the README, so the manual at theforeman.org is where you have to go for both, and a version has to come from the packaging metadata rather than from a tag. Plugins are Rails engines with frontends loaded through webpack module federation, so a plugin that assumes its own bundle will need to fit that arrangement. And the docker-compose.yml in the root has default database credentials in plain text with example.com hostnames, which makes it a development file by inference rather than by anything it says about itself.

Frequently asked questions

What is Foreman?

An application that automates the server lifecycle, covering provisioning, configuration management through Puppet, Ansible, Chef, Salt and smart proxies, orchestration and monitoring, on bare metal, on virtual machines or in the cloud. It exposes a web frontend, a CLI and a REST API, and its plugins are Rails engines packaged as gems.

How do I install Foreman?

The README carries no install command. It points at the quickstart section of the manual and, for setups with particular needs, the installation scenarios section, both on theforeman.org.

What license is Foreman released under?

The licensing section states the GNU GPL v3 or newer, with some exceptions, and the repository's license field records GPL-3.0. The copyright line reads 2009-2020 for Ohad Levy, Paul Kelly and their respective owners, with all other holders listed in a separate Contributors file.

What does Foreman use Node for?

Only for the asset build. The npm manifest is named TheForemanDevDeps, is marked private, and its description says Foreman isn't really a node module: the dependencies exist to build the webpack bundle. Its engines field requires node from 22.0.0 up to but not including 23.0.0, and npm from 8.0.0.

Official sources

  1. Issues
  2. License: GPL-3.0
  3. Project website
  4. README
  5. theforeman/foreman on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/theforeman-foreman.svg)](https://hysenlabs.com/projects/theforeman-foreman)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/theforeman-foreman.svg)](https://hysenlabs.com/projects/theforeman-foreman)

Was this useful?