farmOS vs Ekylibre: Best Open-Source Farm Management Systems 2026

Managing a modern farm means tracking field operations, crop rotations, equipment maintenance, livestock records, harvest yields, and regulatory compliance — often across dozens of hectares. Commercial farm management software (FMIS) typically charges per-acre or per-user pricing, locks your data behind proprietary APIs, and requires an internet connection to access your own records.

Open-source, self-hosted farm management platforms solve all three problems. You own the data, control the infrastructure, and scale without per-acre licensing fees. In this guide, we compare the two leading platforms — farmOS and Ekylibre — and walk through complete Docker deployment for each.

Why Self-Host Your Farm Management System

Full data ownership and portability. Farm records span years of planting dates, soil test results, harvest yields, chemical applications, and livestock health logs. When this data lives in a SaaS platform, you are locked into their export formats, retention policies, and pricing tiers. Self-hosting means your data lives on your infrastructure in standard database formats. If you ever switch platforms, you take the raw data with you.

Offline access in the field. Many farms operate in areas with poor or unreliable cellular coverage. A self-hosted FMIS running on a local server or edge device stays accessible regardless of internet connectivity. farmOS even supports offline field data collection through its mobile-friendly interface.

No per-acre or per-user fees. Commercial platforms like Granular, Climate FieldView, and FarmLogs charge based on acreage or seat count. A 500-acre farm can easily pay $2,000–$5,000 per year. A self-hosted instance on a $10/month VPS or a Raspberry Pi at the farm office costs a fraction of that and handles unlimited acres, users, and fields.

Custom workflows and integrations. Self-hosted platforms let you build custom record types, integrate with weather APIs, connect to IoT sensor networks for soil moisture and temperature monitoring, and export data in whatever format your agronomist or regulatory body requires. For farm sensor integration ideas, check our self-hosted IoT platform guide or MQTT broker comparison.

farmOS

GitHub stats: 1,268 stars · Last updated: April 23, 2026 · Language: PHP (Drupal-based)

farmOS is a Drupal-based web application designed specifically for farm record keeping. It is the most widely adopted open-source FMIS, backed by a community of farmers, developers, and agricultural researchers. The project follows a modular architecture — core provides the basic framework (areas, assets, logs, plans), and contributed modules add functionality for specific farm types (livestock, orchards, aquaculture, grain).

Key Features

• Asset tracking — register fields, equipment, animals, seeds, and water sources as distinct assets with custom attributes
• Log system — record planting, harvesting, spraying, maintenance, observations, and inputs with timestamps and geo-coordinates
• Map integration — visualize fields, assets, and log entries on interactive maps using OpenLayers
• Plan management — create crop rotation plans, planting schedules, and seasonal workflows
• Role-based access control — granular permissions for farm workers, managers, and external auditors
• REST API — JSON:API-based endpoints for programmatic access, enabling integrations with weather stations, IoT sensors, and external data pipelines
• Mobile-friendly — responsive design works on tablets and phones for field data entry
• Multi-farm support — manage multiple farm sites from a single installation
• Module ecosystem — 30+ contributed modules for livestock, orchards, composting, irrigation, and more

Docker Compose Deployment

farmOS is built on Drupal and runs on a LAMP/LEMP stack with PostgreSQL. The official Docker image is available at farmos/farmos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

services:
  farmos-db:
    image: postgres:15-alpine
    restart: always
    volumes:
      - farmos_db_data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: farmos
      POSTGRES_USER: farmos
      POSTGRES_PASSWORD: changeme_farmos_db
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U farmos"]
      interval: 10s
      timeout: 5s
      retries: 5

  farmos-www:
    image: farmos/farmos:3.x
    restart: always
    depends_on:
      farmos-db:
        condition: service_healthy
    volumes:
      - farmos_sites:/opt/drupal/web/sites
    ports:
      - "8080:80"
    environment:
      FARMOS_DB_HOST: farmos-db
      FARMOS_DB_NAME: farmos
      FARMOS_DB_USER: farmos
      FARMOS_DB_PASS: changeme_farmos_db

volumes:
  farmos_db_data:
  farmos_sites:

First-time setup: After starting the stack, navigate to http://your-server:8080 and run the Drupal installation wizard. The installer configures the database connection and creates the admin account. Install contributed modules from the farmOS module repository to add livestock, orchard, or aquaculture support.

Backup strategy: The farmos_db_data volume holds all records. The farmos_sites volume holds configuration, custom modules, and uploaded files. Back up both volumes regularly:

1
2
3
4
5

docker run --rm -v farmos_db_data:/data -v $(pwd):/backup alpine \
  tar czf /backup/farmos-db-$(date +%Y%m%d).tar.gz -C /data .

docker run --rm -v farmos_sites:/data -v $(pwd):/backup alpine \
  tar czf /backup/farmos-sites-$(date +%Y%m%d).tar.gz -C /data .

Ekylibre

GitHub stats: 476 stars · Last updated: April 15, 2026 · Language: Ruby

Ekylibre is a Ruby on Rails-based farm management platform developed in France with a strong focus on European farming practices and regulatory compliance. It provides a comprehensive suite for crop management, animal husbandry, and financial tracking, with particular strength in viticulture and mixed farming operations.

Key Features

• Crop management — track planting dates, growth stages, treatments, and harvests with calendar views
• Animal management — livestock tracking with birth records, health events, and herd management
• Financial module — cost tracking per plot, per crop, and per season with basic accounting features
• Regulatory compliance — built-in support for European agricultural regulations, chemical application logs, and traceability requirements
• Plot mapping — visual map interface for field boundaries, crop zones, and intervention areas
• Weather integration — connect to weather data sources for growing degree day calculations and frost alerts
• Document management — attach invoices, certificates, photos, and PDFs to records
• Multi-language support — available in French, English, Spanish, and Portuguese
• Data export — export records in standard formats for regulatory reporting and accountant review

Docker Compose Deployment

Ekylibre uses PostgreSQL, Redis, and a Rails application server. Here is a production-ready compose configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

services:
  ekylibre-db:
    image: postgres:15-alpine
    restart: always
    volumes:
      - ekylibre_db_data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: ekylibre
      POSTGRES_USER: ekylibre
      POSTGRES_PASSWORD: changeme_ekylibre_db
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ekylibre"]
      interval: 10s
      timeout: 5s
      retries: 5

  ekylibre-redis:
    image: redis:7-alpine
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  ekylibre-web:
    image: ekylibre/ekylibre:latest
    restart: always
    depends_on:
      ekylibre-db:
        condition: service_healthy
      ekylibre-redis:
        condition: service_healthy
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://ekylibre:changeme_ekylibre_db@ekylibre-db:5432/ekylibre
      REDIS_URL: redis://ekylibre-redis:6379/0
      RAILS_ENV: production
      SECRET_KEY_BASE: changeme_generate_with_rails_secret
    volumes:
      - ekylibre_data:/app/data

volumes:
  ekylibre_db_data:
  ekylibre_data:

Note: Ekylibre’s Docker image may require building from source if a pre-built image is not available on Docker Hub. Clone the repository and build the image locally:

1
2
3

git clone https://github.com/ekylibre/ekylibre.git
cd ekylibre
docker build -t ekylibre/ekylibre:latest -f docker/Dockerfile .

Generate a secure secret key:

1

openssl rand -hex 64

Use this value for SECRET_KEY_BASE in your compose file before starting the stack.

Comparison Table

Which One Should You Choose?

Choose farmOS if:

• You run a diverse operation (crops + livestock + orchards) and need modular extensibility
• You want the largest community and most third-party integrations
• You need strong IoT and sensor data integration (farmOS’s JSON:API works well with time-series databases — see our time-series database guide for storing sensor data)
• You prefer a well-documented, Drupal-based platform with a mature module ecosystem
• You need multi-farm support (e.g., managing multiple properties or client farms)

Choose Ekylibre if:

• You operate in Europe and need built-in support for EU Common Agricultural Policy (CAP) reporting
• You want financial tracking and cost accounting built into the core platform
• You run a viticulture or mixed farming operation (Ekylibre has particular strength here)
• You prefer Ruby on Rails and want a more opinionated, integrated platform
• Your team is French-speaking or operates primarily in Western Europe

Migration Considerations

Both platforms use PostgreSQL, making database-level migration feasible with proper ETL scripting. farmOS stores data in Drupal’s entity system (nodes, fields, paragraphs), while Ekylibre uses Rails ActiveRecord models. Export data to a neutral format (CSV, GeoJSON) first, then import into the target system.

For farm inventory tracking that complements either FMIS, consider pairing with a dedicated inventory system like Grocy or Homebox for equipment, supplies, and input stock management.

FAQ

Is farmOS free to use?

Yes, farmOS is released under the GPL-2.0 license and is completely free to download, install, and use. There are no paid tiers or feature restrictions. The project is sustained by community contributions, grants, and consulting services offered by core developers.

Can I run farmOS or Ekylibre on a Raspberry Pi?

Yes. farmOS runs comfortably on a Raspberry Pi 4 with 4GB RAM using the official Docker image. Ekylibre (Ruby on Rails) is more resource-intensive and benefits from 8GB RAM, but can run on a Pi 4 for small farms with fewer than 5 concurrent users.

Does farmOS work offline?

farmOS’s web interface requires a network connection to the server. However, if you host farmOS on a local network server (e.g., at the farm office), field devices on the same Wi-Fi network can access it without an internet connection. For truly offline field data collection, you can use farmOS’s mobile-responsive interface cached via a service worker, or pair it with offline-capable data collection tools that sync when connectivity returns.

What types of farms are these platforms best suited for?

farmOS is designed for small to medium diversified farms (5–500 acres) but scales to larger operations through its modular architecture. It excels at mixed crop-livestock operations, organic farms, and research stations. Ekylibre is particularly strong for European mixed farms, vineyards, and operations that need regulatory compliance reporting. Both handle grain, vegetable, and livestock operations well.

Can I integrate weather data and IoT sensors?

Both platforms support external data integration via their APIs. farmOS’s JSON:API makes it straightforward to push sensor readings (soil moisture, temperature, humidity) as log entries. Ekylibre can ingest weather data through its API or via Rails background jobs. For a complete IoT sensor pipeline, consider using an MQTT broker like Mosquitto to collect sensor data, then bridge it into your FMIS.

Do these platforms support multiple users and permission levels?

Yes. farmOS uses Drupal’s robust role and permission system, allowing you to create custom roles (farm worker, field manager, auditor) with granular access to specific asset types and log categories. Ekylibre supports user accounts with role-based access, though its permission model is less granular than Drupal’s.

How do I back up my farm data?

Both platforms store all data in PostgreSQL. Use pg_dump to create database backups, and archive the file storage volumes (farmOS’s sites directory, Ekylibre’s data volume). Automate with a cron job:

1
2

# Automated daily backup
0 2 * * * docker exec ekylibre-db pg_dump -U ekylibre ekylibre | gzip > /backup/ekylibre-$(date +\%Y\%m\%d).sql.gz

JSON-LD Structured Data