What is your odoo development setup?

[BerndHme]

Hi,

I would like to open this discussion to find out what are common, stable and sound development setups for odoo development,
and to find out what experienced odoo developers use for their daily development.
I've been struggling to find the right one, what IDE to use and what extensions to use to get maximum snippets, intellisense and linting support.

What is recommended, what works for you?

I'm fairly new at odoo development,
I like the software, but I don't like the development experience as much as I like more adult frameworks like .NET and Angular.
The main reason is that I find it hard to find good stable tooling for the server- and web-framework.
I'm also not as keen on using unverified extensions from the marketplace,
some are old and have many installs, but are not relevant for the new 18.0 and 19.0 versions,
others are new and maybe promising, but I'd rather stick to the official ones just for safety.

What editor / IDE do you use, and why?

• VSCode
• VSCodium
• PyCharm
• ...

What OS do you use to develop in, and why?

• Windows
• WSL
• Linux
• Mac
• Devcontainers
• ...

My setup for now.

I'd be happy to hear what you think of it, what can be better, what is your experience and opinion.

Until recently I entirely developed on plain Windows11, now I still use windows but I develop in WSL and use docker containers to run the app.

Folder structure

For the plain windows setup, I have this workspace folder structure with all repose as below.

18.0
|- .config/
|   |- .flake8
|   |- odools.toml
|
|- .venv/
|- custom/
|   |- proj_1/
|   |- proj_2/
|   |- proj_3/
|
|- enterprise/
|- odoo/
|- jsconfig.json

Also I've set this up for each version of odoo, one directory for each

• 18.0
• 19.0

Launch settings

I do this full source code setup because I want to debug the entire application.
So I start odoo as a windows process entirely, I run python from a .venv with debugpy installed.
I let vscode start the odoo-bin file and automatically attach debugpy.
This way I can set breakpoints throughout the entire source code.
This is an example of .vscode/launch.json config.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "odoo",
            "type": "debugpy",
            "request": "launch",
            "program": "${workspaceFolder}/odoo/odoo-bin",
            "args": [
                "--config=${workspaceFolder}/.config/odoo.conf",
                "--db_user=odoo",
            ],
            "console": "integratedTerminal",
        },
    ],
}

Extensions

The extensions I use currently are these.
What do you use?

• Odoo (odoo-ls ... the one that has the repo of which I'm writing this message right now)
• Owl Vision (odoo)
• Python (ms)
• Pylance (ms)
• Python Debugger (ms)
• Flake8 (ms - linter)
• autopep8 (ms - formatter)
• XML (Read Hat)

Flake8 & autopep8

For the Flake8 and autopep8 formatting I use this config for now.
I suppress some errors and warnings so I'm a bit more free to structure the code.
This is my .config/.flake8 file.

[flake8]
ignore = E501, W503, F841, F401, E301, E302, E303, E402

Odoo

I've placed the odools.toml inside the .config directory, so I can actually create a git repo for this and back it up remotely.
This is my .config/odools.toml file.

[[config]]
name = "root"
python_path = "python"
odoo_path = "../odoo"
addons_paths = [
    "../odoo/addons",
    "../enterprise",
    "../tutorials",
]
diag_missing_imports = "only_odoo"

[[config.diagnostic_filters]]
codes = ["OLS.*"]
paths = [
    "**/odoo/*/odoo/*",
    "**/odoo/*/enterprise/*",
]

Workspace settings

This is my workspace .vscode/settings.json.

{
    "python.analysis.extraPaths": [
        "${workspaceFolder}/.venv/Lib/site-packages",
        "${workspaceFolder}/odoo",
    ],

    "python.analysis.diagnosticSeverityOverrides": {
        "reportMissingImports": "none"
    },

    // "python.languageServer": "None",
    "autopep8.args": [
        "--global-config=.config/.flake8"
    ],
    "flake8.args": [
        "--config=.config/.flake8"
    ],
    "Odoo.selectedProfile": "root",
    "Odoo.serverConfigPath": "C:/codeB/odoo/18.0/.config/odools.toml",
    "python.analysis.inlayHints.functionReturnTypes": true,
    "python.analysis.inlayHints.variableTypes": true,
}

You notice I still use the Pylance language server.
I use this because I actually like the colorization it brings on symbols,
and also I recently discovered these inlay hints settings, which I find very useful for reading and debugging code.

    "python.analysis.inlayHints.functionReturnTypes": true,
    "python.analysis.inlayHints.variableTypes": true,

I've also created a feature request to implement this functionality in the odoo-ls extension as well.

jsonfig.json

For easy navigation between javascript modules,
I've got a jsconfig.json setup with these pathmappings, maybe it's not 100% correct, but it helps.
This is my jsconfig.json file

{
    "compilerOptions": {
        "target": "ES2022",
        "module": "ES2022",
        "moduleResolution": "node",
        "baseUrl": ".",
        "paths": {
            // Core Odoo web framework
            "@web/*": [ "odoo/addons/web/static/src/*" ],
            "@odoo/*": [ "odoo/addons/web/static/src/*" ],
            "@odoo/owl": [ "odoo/addons/web/static/lib/owl/owl.js" ],

            // Standard Odoo modules
            "@sale/*": [ "odoo/addons/sale/static/src/*" ],
            "@account/*": [ "odoo/addons/account/static/src/*" ],
            "@purchase/*": [ "odoo/addons/purchase/static/src/*" ],
            "@mail/*": [ "odoo/addons/mail/static/src/*" ],
            "@stock/*": [ "odoo/addons/stock/static/src/*" ],
            "@portal/*": [ "odoo/addons/portal/static/src/*" ],
            "@point_of_sale/*": [ "odoo/addons/point_of_sale/static/src/*" ],
            "@website/*": [ "odoo/addons/website/static/src/*" ],
            "@web_editor/*": [ "odoo/addons/web_editor/static/src/*" ],
            "@product/*": [ "odoo/addons/product/static/src/*" ],
            "@hr/*": [ "odoo/addons/hr/static/src/*" ],
            "@crm/*": [ "odoo/addons/crm/static/src/*" ],
            "@project/*": [ "odoo/addons/project/static/src/*" ],
            "@mrp/*": [ "odoo/addons/mrp/static/src/*" ],
            "@calendar/*": [ "odoo/addons/calendar/static/src/*" ],

            // Enterprise modules (adjust paths if needed)
            "@web_enterprise/*": [ "enterprise/web_enterprise/static/src/*" ],
            "@web_studio/*": [ "enterprise/web_studio/static/src/*" ],
            "@web_mobile/*": [ "enterprise/web_mobile/static/src/*" ],
            "@account_accountant/*": [ "enterprise/account_accountant/static/src/*" ],
            "@account_reports/*": [ "enterprise/account_reports/static/src/*" ],
            "@sale_enterprise/*": [ "enterprise/sale_enterprise/static/src/*" ],
            "@purchase_enterprise/*": [ "enterprise/purchase_enterprise/static/src/*" ],
            "@mrp_workorder/*": [ "enterprise/mrp_workorder/static/src/*" ],
            "@quality_control/*": [ "enterprise/quality_control/static/src/*" ],
            "@helpdesk/*": [ "enterprise/helpdesk/static/src/*" ],
            "@planning/*": [ "enterprise/planning/static/src/*" ],
            "@timesheet_grid/*": [ "enterprise/timesheet_grid/static/src/*" ],
            "@knowledge/*": [ "enterprise/knowledge/static/src/*" ],
            "@documents/*": [ "enterprise/documents/static/src/*" ],
            "@sign/*": [ "enterprise/sign/static/src/*" ],
            "@appointment/*": [ "enterprise/appointment/static/src/*" ],

            // Your custom modules
        },
        "checkJs": false,
        "allowSyntheticDefaultImports": true,
        "skipLibCheck": true,
        "lib": [ "ES2022", "DOM" ]
    },
    // "include": [ ],
    "exclude": [
        // Exclude everything else to improve performance
        // Path mappings still work, but these won't be deeply analyzed
        "node_modules",
        "**/node_modules/*",
        "odoo/**/*",
        "enterprise/**/*",
        "custom/**/*",
        "**/static/lib/**/*",
        "**/static/tests/**/*",
        "**/*.min.js",
        "**/dist/**/*",
        "**/build/**/*",
        "**/__pycache__/**/*",
        "**/*.pyc"
    ]
}

Other

At the moment I don't use any snippets ... but I'm going to try out the Odoo Shortcuts extension from mvintg
... seems an interesting one.

The thing about snippets, I actually quite rely on copilot chat.
If I need a fresh module setup, I plan out context with the planning agent,
and let it generate a complete structure for me which I then abstract and refine.

WSL & Docker

Recently I've set up docker containers to run the db and odoo instance in.
But because I want to be able to debug easily with breakpoints, I needed to mount the source code entirely on the odoo container.
If I do this with the source code stored on windows itself, reading and writing is terribly slow, so I recently moved to WSL.
Using mounted source code from there is way more performant than mounting from windows.
So now I use a vscode remote window to WSL, where I created this development workspace.

Folder structure

My new workspace looks like this.

18.0 [WSL:UBUNTU]
|- .config/
|   |- .flake8
|   |- odools.toml
|
|- .venv/
|- .docker
|   |- proj_1/
|   |   |- odoo.conf
|   |   |- compose.yaml
|   |
|   |- proj_2/
|   |- proj_3/
|   |- odoo/
|       |- odoo.conf
|       |- compose.yaml
|   |- Dockerfile
|
|- custom/
|   |- proj_1/
|   |- proj_2/
|   |- proj_3/
|
|- enterprise/
|- odoo/
|- jsconfig.json

Dockerfile

I use the official odoo:18.0 image as a base, so I don't need to manage all necessary dependencies for running odoo.
I remove the installed odoo package from it, therefore removing the source code so I can mount my own source code.
This way I'm certain I have only one source of truth.
If I don't remove the odoo package, the core odoo modules still run from the package instead of from the source code I mount because of entries in the system-path variable if I'm correct,
resulting in not being able to trigger breakpoints from the core addons.

The whole reason for manipulating this image is to be able to use it for debugging.
So I also install venv to create a virtual environment in the image, and install the debugpy package there.
I also re-install the odoo-user, and set file permissions.

This is my .docker/Dockerfile

FROM odoo:18.0
USER root
RUN apt-get update \
    && apt-get purge -y odoo || true \
    && apt-get install -y --no-install-recommends python3-venv \
    && rm -rf /usr/lib/python3/dist-packages/odoo \
    && rm -rf /var/lib/apt/lists/*
RUN id odoo || adduser --system --home /var/lib/odoo --group odoo
RUN mkdir -p /var/lib/odoo /var/lib/odoo/sessions \
    && chown -R odoo:odoo /var/lib/odoo
RUN python3 -m venv --system-site-packages /opt/odoo-venv \
    && /opt/odoo-venv/bin/pip install --no-cache-dir debugpy
USER odoo

Compose files

Below are the compose files I use.
I use the same database for all the project containers, maybe that is bad practice, I'm happy to hear your thoughts.
Remember this is a development setup. I wouldn't do this in production, but maybe I also shouldn't in development, I don't know.

This is my .docker/postgres/compose.yaml.

networks:
  odoo-net:
    name: odoo-net

services:
  postgres:
    image: postgres:18
    restart: unless-stopped
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: admin
    volumes:
      - postgres-data:/var/lib/postgresql
    networks:
      - odoo-net
    ports:
      - 5435:5432

volumes:
  postgres-data:

This is my .docker/odoo/compose.yaml

networks:
  odoo-net:
    external: true

services:
  odoo:
    image: odoo-debug:18
    build:
      context: ..
      dockerfile: Dockerfile
    restart: unless-stopped
    ports:
      - "8070:8069"
      - "5680:5680"
    volumes:
      - ../../odoo:/opt/odoo/odoo
      - ../../enterprise:/opt/odoo/enterprise
      - ./odoo.conf:/etc/odoo/odoo.conf
      - odoo-data:/var/lib/odoo
    networks:
      - odoo-net
    command:
      - /opt/odoo-venv/bin/python
      - -m
      - debugpy
      - --listen
      - "0.0.0.0:5680"
      - /opt/odoo/odoo/odoo-bin
      - -c
      - /etc/odoo/odoo.conf

volumes:
  odoo-data:

PyCharm

I've just recently installed PyCharm to try it out.
Here my questions are

• Can you have a decent setup just by using the free version?
• There's this paid extension Odoo IDE from Trịnh Anh Ngọc
• Maybe this is all you need?

Regarding the WSL setup, I noticed that you can't have a remote window to WSL with the free version of PyCharm,
at least to my understanding.
So here I assume you're actually better of using Mac of Linux for development, correct?
Maybe that is even the default way?

On the other hand, I actually like just using vscode because of its versatility, but that shouldn't be a reason not to try other setups I think.

VSCodium

I haven't tried this.

• What are recommended setups with this?
• Is it convenient?
• I've read that you can't use the normal Python extensions from microsoft, but that you rather must use Pyright ?
• Maybe it's recommended to use just VSCodium if you want a complete open source setup?
  • But is this setup then still sound and easy to use?

Main Goal

So to recap, the reason why I start this discussion is to find out what is a very good and comfortable development setup for Odoo.

• What are tested and tried extensions and what are your experiences?
• What do you think of the setup above, what do you like about it, what do you dislike about it?
• What can be done better or differently?
• What is the setup of developers at odoo itself?
  • Maybe they have their own internal extensions?

If people can share their thoughts, I think it would help me and possibly others a great deal,
and who knows stimulate the growth of the Odoo platform from the perspective of developers and technical people,
making their lives a bit more easy and help new people quickly set up and learn the framework and all its aspects.

Thanks.

[fda-odoo]

Hello @BerndHme ,
To answer to this discussion with the point of view of the OdooLS team, here are some notes:

• OdooLS is there to fill all the needs a developer could have when developing with Odoo, without depending to many extensions on the marketplace. We know we still don't cover everything, but we plan to add other parts to the tool: Javascript support, debugging tools, etc... and of course continue to improve what is already there
• Regarding OS, OdooLS is working on all main OS, but is way faster on linux/macOS (due to better filesystem).
• OdooLS is available for Pycharm too, but the integration is probably less good, as they are still trying to improve their LSP support. Free version of Pycharm is enough though to run OdooLS.
  For other points, I'll let the community discuss them. As I'm working on OdooLS, I only use Rust extensions ! :D