Add multi-arch support to release workflows and installation scripts

Release v0.7.0

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: 'https://dalink.to/dexoron'

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,51 @@
+---
+name: Bug Report
+about: Something is broken or behaves unexpectedly
+title: "[bug] "
+labels: bug
+assignees: ''
+---
+
+## Description
+
+<!-- A clear and concise description of the bug -->
+
+## Steps to Reproduce
+
+1. 
+2. 
+3. 
+
+## Expected Behavior
+
+<!-- What should have happened -->
+
+## Actual Behavior
+
+<!-- What actually happened, include full error output -->
+
+```
+paste error output here
+```
+
+## Environment
+
+- **DCR version** (`dcr --version`): 
+- **OS**: 
+- **Compiler / toolchain** (`gcc --version` or `clang --version`): 
+
+## Minimal Reproducible Project
+
+<!-- If possible, share a minimal dcr.toml + source that reproduces the issue -->
+
+```toml
+# dcr.toml
+```
+
+```c
+// src/main.c
+```
+
+## Additional Context
+
+<!-- Anything else that might help -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,35 @@
+---
+name: Feature Request
+about: Suggest an idea or improvement
+title: "[feat] "
+labels: enhancement
+assignees: ''
+---
+
+## Problem / Motivation
+
+<!-- What problem does this solve? What are you trying to do that's currently hard or impossible? -->
+
+## Proposed Solution
+
+<!-- Describe what you want. Be as specific as possible — CLI flags, config syntax, behavior -->
+
+## Example
+
+<!-- Show how it would look in practice (command, dcr.toml snippet, output) -->
+
+```sh
+# example command
+```
+
+```toml
+# example config
+```
+
+## Alternatives Considered
+
+<!-- Have you tried workarounds? Are there other ways to solve this? -->
+
+## Additional Context
+
+<!-- Links, prior art, related issues, etc. -->

.github/workflows/aur.yml

@@ -1,136 +0,0 @@
-name: AUR Publish
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Tag version without v prefix (e.g. 0.2.2)"
-        required: true
-  push:
-    tags:
-      - "v*"
-
-permissions:
-  contents: read
-
-jobs:
-  publish-aur:
-    runs-on: ubuntu-latest
-    environment: aur
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Derive version and checksum
-        id: meta
-        shell: bash
-        run: |
-          set -euo pipefail
-          if [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" ]]; then
-            PKGVER="${{ inputs.version }}"
-          else
-            PKGVER="${GITHUB_REF_NAME#v}"
-          fi
-          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/v${PKGVER}.tar.gz"
-          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
-
-          echo "pkgver=$PKGVER" >> "$GITHUB_OUTPUT"
-          echo "source_url=$SRC_URL" >> "$GITHUB_OUTPUT"
-          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
-
-      - name: Render AUR metadata
-        shell: bash
-        run: |
-          set -euo pipefail
-          PKGVER='${{ steps.meta.outputs.pkgver }}'
-          SRC_URL='${{ steps.meta.outputs.source_url }}'
-          SHA256='${{ steps.meta.outputs.sha256 }}'
-
-          cat > packaging/aur/dcr/PKGBUILD <<PKG
-          pkgname=dcr
-          pkgver=${PKGVER}
-          pkgrel=1
-          pkgdesc="Cargo-like utility to manage C/C++ projects"
-          arch=('x86_64' 'aarch64')
-          url="https://github.com/dexoron/dcr"
-          license=('MIT')
-          depends=('gcc-libs')
-          makedepends=('cargo')
-          options=('!lto')
-          optdepends=(
-            'gcc: build C/C++ projects with GCC'
-            'clang: build C/C++ projects with Clang'
-          )
-          source=("\$pkgname-\$pkgver.tar.gz::\$url/archive/refs/tags/v\$pkgver.tar.gz")
-          sha256sums=('${SHA256}')
-
-          build() {
-            cd "\$srcdir/\$pkgname-\$pkgver"
-            export CARGO_PROFILE_RELEASE_LTO=false
-            export RUSTFLAGS="\${RUSTFLAGS:-}"
-            export RUSTFLAGS="\${RUSTFLAGS/-C link-arg=-fuse-ld=lld/}"
-            cargo build --release --locked
-          }
-
-          package() {
-            cd "\$srcdir/\$pkgname-\$pkgver"
-            install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
-            install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
-          }
-          PKG
-
-          cat > packaging/aur/dcr/.SRCINFO <<SRC
-          pkgbase = dcr
-          	pkgdesc = Cargo-like utility to manage C/C++ projects
-          	pkgver = ${PKGVER}
-          	pkgrel = 1
-          	url = https://github.com/dexoron/dcr
-          	arch = x86_64
-          	arch = aarch64
-          	license = MIT
-          	makedepends = cargo
-          	depends = gcc-libs
-          	optdepends = gcc: build C/C++ projects with GCC
-          	optdepends = clang: build C/C++ projects with Clang
-            options = !lto
-          	source = dcr-${PKGVER}.tar.gz::${SRC_URL}
-          	sha256sums = ${SHA256}
-
-          pkgname = dcr
-          SRC
-
-      - name: Push to AUR
-        env:
-          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
-          AUR_PACKAGE: dcr
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          if [[ -z "${AUR_SSH_PRIVATE_KEY:-}" ]]; then
-            echo "AUR_SSH_PRIVATE_KEY secret is missing"
-            exit 1
-          fi
-
-          install -d -m 700 ~/.ssh
-          printf '%s\n' "$AUR_SSH_PRIVATE_KEY" > ~/.ssh/aur
-          chmod 600 ~/.ssh/aur
-          ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
-
-          export GIT_SSH_COMMAND='ssh -i ~/.ssh/aur -o IdentitiesOnly=yes'
-          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
-          cp packaging/aur/dcr/PKGBUILD aur-repo/PKGBUILD
-          cp packaging/aur/dcr/.SRCINFO aur-repo/.SRCINFO
-
-          cd aur-repo
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-          if git diff --quiet; then
-            echo "No AUR changes"
-            exit 0
-          fi
-
-          git add PKGBUILD .SRCINFO
-          git commit -m "dcr ${{ steps.meta.outputs.pkgver }}"
-          git push

.github/workflows/dexoron-packages-index.yml

@@ -0,0 +1,109 @@
+name: Dexoron Packages Index
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Версия (тег) для ручного импорта пакетов (например, v0.6.9)"
+        required: true
+        type: string
+  workflow_run:
+    workflows: ["Release"]
+    types:
+      - completed
+
+permissions:
+  contents: read
+
+jobs:
+  update-packages-index:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event_workflow_run.conclusion == 'success' }}
+
+    steps:
+      - name: Checkout Central Packages Repo
+        uses: actions/checkout@v4
+        with:
+          repository: 'dexoron/packages'
+          token: ${{ secrets.PACKAGES_REPO_TOKEN }}
+          path: 'central-packages'
+
+      - name: Import GPG Key
+        uses: crazy-max/ghaction-import-gpg@v6
+        with:
+          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
+
+      # --- Загрузка артефактов (сохранена прежняя логика) ---
+      - name: Download Artifacts
+        if: ${{ github.event_name == 'workflow_run' }}
+        uses: actions/download-artifact@v4
+        with:
+          path: central-packages/
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+
+      - name: Download Packages from Release Assets
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ inputs.tag }}
+        run: |
+          gh release download "$TAG" --repo dexoron/dcr --pattern "*.pkg.tar.zst" --dir central-packages/archlinux/x86_64/ --clobber
+          gh release download "$TAG" --repo dexoron/dcr --pattern "*.deb" --dir central-packages/debian/ --clobber
+          gh release download "$TAG" --repo dexoron/dcr --pattern "*.rpm" --dir central-packages/fedora/x86_64/ --clobber
+
+      # --- ИНДЕКСАЦИЯ И ПОДПИСЬ ---
+
+      - name: Update Pacman Database
+        run: |
+          docker run --rm \
+            -v ${{ github.workspace }}/central-packages:/packages \
+            -v ~/.gnupg:/root/.gnupg \
+            archlinux:latest \
+            bash -c '
+              cd /packages/archlinux/x86_64 && \
+              packages=(*.pkg.tar.zst) && \
+              repo-add --sign dexoron.db.tar.gz "${packages[@]}" && \
+              ln -sf dexoron.db.tar.gz dexoron.db && \
+              ln -sf dexoron.files.tar.gz dexoron.files
+            '
+      - name: Fix GPG permissions after Docker
+        run: sudo chown -R runner:runner ~/.gnupg
+
+      - name: Update Debian APT Repository Index
+        run: |
+          sudo apt-get update && sudo apt-get install -y dpkg-dev
+          cd central-packages/debian
+          dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz
+          
+          echo "Origin: Dexoron Packages" > Release
+          echo "Label: Dexoron Packages" >> Release
+          echo "Suite: stable" >> Release
+          echo "Codename: stable" >> Release
+          echo "Architectures: amd64" >> Release
+          echo "Components: main" >> Release
+          echo "Description: Dexoron binary package repository" >> Release
+          echo "Date: $(date -uR)" >> Release
+          echo "SHA256:" >> Release
+          echo " $(sha256sum Packages.gz | awk '{print $1" "$2}')" >> Release
+          
+          gpg --batch --yes --pinentry-mode loopback --local-user 74322D39483E9C9E8C86C0AA0770A5C2A2A82DAC --detach-sign --armor --output Release.gpg Release
+          gpg --batch --yes --pinentry-mode loopback --local-user 74322D39483E9C9E8C86C0AA0770A5C2A2A82DAC --clearsign --output InRelease Release
+
+      - name: Update Fedora DNF Repository Index
+        run: |
+          sudo apt-get update && sudo apt-get install -y createrepo-c
+          cd central-packages/fedora/x86_64
+          createrepo_c .
+          gpg --batch --yes --detach-sign --armor --output repodata/repomd.xml.asc repodata/repomd.xml
+
+      - name: Push to dexoron/packages
+        run: |
+          cd central-packages
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add .
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: update and sign repositories"
+            git push
+          fi

.gitignore

@@ -3,3 +3,5 @@ sandbox/**
 .idea/
 .vscode/
 .env
+
+personal/

AGENTS.md

@@ -0,0 +1,56 @@
+# AGENTS.md
+
+## Quick start
+
+```bash
+cargo build --release && ./target/release/dcr setup
+```
+
+## Pre-PR (CI) gate
+
+```bash
+cargo fmt --all --check
+cargo clippy --all-targets --all-features -- -D warnings
+cargo check --all-targets --all-features
+cargo test
+```
+
+CI (`.github/workflows/ci.yml`) runs fmt, clippy, check — **not** tests.
+
+## Tests
+
+- Integration tests in `tests/` build the dcr binary and run it in temp dirs under `sandbox/cli-tests/` (gitignored).
+- Some tests **skip** if no C compiler (`gcc`/`clang`/`cc`) is found at runtime.
+- Compiler can be overridden via `DCR_COMPILER` or `DCR_CC` env vars.
+- Tests use `$CARGO_BIN_EXE_dcr` when available, else `target/debug/dcr`.
+
+## Architecture
+
+- **Single Rust package** (edition 2024), not a workspace. Only one binary: `dcr`.
+- **Entrypoint**: `src/main.rs` — matches `args[1]` against command names.
+- **Compiler backends** in `src/core/builder/`: `unix_cc` (gcc/clang), `msvc` (cl/clang-cl), `gas`, `nasm`. Dispatched by matching compiler name string.
+- **Config**: `dcr.toml` (per-project), `~/.dcr/config.toml` (registry), `~/.dcr/index.json` (index). Defaults: `language=c`, `standard=c11`, `compiler=clang`, `kind=bin`.
+- **`build.rs`** embeds `TARGET` as `DCR_TARGET` env var (shown in `--version`).
+- **CLI output** must be in English. Use `utils::log` for messaging.
+
+## Key commands
+
+| Command | Notes |
+|---|---|
+| `dcr new <name>` | Creates project dir |
+| `dcr init` | Init from CWD (must be empty) |
+| `dcr build [--debug\|--release] [--target <triple>]` | Default profile: `--debug` |
+| `dcr run [--debug\|--release]` | Only for `kind = "bin"` |
+| `dcr clean [--debug\|--release] [--all]` | `--all` for workspace roots |
+| `dcr tree` | Dependency tree viewer |
+| `dcr test [--init]` | Runs/test project tests |
+| `dcr gen <vscode\|clion\|compile-commands>` | IDE integration |
+| `dcr --update` | Self-update from GitHub Releases |
+
+## Cross-compilation
+
+`--target` accepts short names (`linux`, `macos`, `windows`) or full triples. In CI, Linux cross-builds use `cargo-zigbuild`. When `build.target` is set in `dcr.toml`, DCR auto-injects `--target=<value>` into cflags (clang). Bare-metal targets (containing `none`/`-elf`/`eabi`/`baremetal`) skip DCR's default compiler flags.
+
+## Dependencies (Cargo)
+
+reqwest (blocking+json+rustls-tls), serde, toml, git2, openssl (vendored), self-replace, sha2, ctrlc.

CHANGELOG.md

@@ -1,10 +1,345 @@
 # Changelog
 
-## [0.2.8] - 2026-03-06
+## [0.7.0] - 2026-06-02
+
 Added:
+
+- **OpenBSD and NetBSD target support** — full platform routing with dynamically generated target triples using `std::env::consts::ARCH` and `std::env::consts::OS`. Affects `build`, `run`, `clean`, and the platform module.
+- **`src/platform/bsd.rs`** — new dedicated BSD platform module shared by FreeBSD, OpenBSD, NetBSD, providing `bin_path`, `lib_path`, `elf_path`, `efi_path`, and `shared_lib_path`.
+- **`build.out_dir` configuration option** — custom output directory that overrides the default `target/<triple>/<profile>` path for final artifacts. Supported in `build`, `run`, and config validation.
+- **`dcr fmt` command** — new CLI command that formats all C/C++ source files (`*.c`, `*.cpp`, `*.h`, `*.hpp`) in `src/` and `tests/` using `clang-format`.
+- **Incremental linking** — `needs_link()` function in `common.rs` that checks whether any object file is newer than the linked output, skipping unnecessary re-linking. Implemented for all backends (`unix_cc`, `msvc`, `gas`, `nasm`).
+- **`build.kind = "none"` and `"custom"`** — two new project kind types for special build scenarios where no standard artifact is produced.
+- **`install_bsd.sh`** — dedicated POSIX-compliant install script for BSD systems (FreeBSD, OpenBSD, NetBSD) with binary download and source build modes.
+- **Linux ARM64 support in `install.sh`** — added `Linux:aarch64|Linux:arm64` target triple detection for pre-built binary downloads.
+- **BSD OS detection in `install.sh`** — FreeBSD, OpenBSD, NetBSD detection and target triple resolution.
+- **`rust-toolchain.toml`** — explicit `stable` channel toolchain pinning.
+- **Nix support** — `flake.nix` for Nix package manager. Run via `nix run github:dexoron/dcr` or install with `nix profile install github:dexoron/dcr`. Contributed by community contributor.
+- **Snapcraft publish** — `dcrup` published on Snapcraft. Install with `sudo snap install dcrup`.
+- **Integration tests** — `build_with_target_config` (verifies `build.target = "linux"`) and `build_with_out_dir` (verifies custom output directory).
+- **`get_build_string_with_profile` made `pub`** — so `run.rs` can resolve custom output directory configuration.
+
+Changed:
+
+- **`build.target` semantics changed** — now strictly holds the target triple (e.g. `x86_64-unknown-linux-gnu`) or a short name (`linux`, `macos`, `windows`). No longer doubles as a custom output directory — that functionality moved to `build.out_dir`.
+- **`build.standard` made optional** — changed from `String` to `Option<String>`. Validation only enforces non-empty for non-ASM languages. Skipped in `dcr.toml` output when empty.
+- **`dcr run` with `out_dir`** — now resolves target directory respecting `build.out_dir` when configured, via `get_build_string_with_profile()` from `build.rs`.
+- **`collect_sources()` returns empty vec** instead of error when no source files are found, allowing `kind = "none"` or `kind = "custom"` projects to have no source files.
+- **CI/CD release workflow refactored** — `git2` made target-specific (no vendored-openssl on Windows), Zig-based cross-compilation for non-x86_64 Linux targets, Arch Linux package version sanitization (dashes → dots), NetBSD `gmake` symlink.
+- **README compatibility table** — FreeBSD, OpenBSD, NetBSD build/runtime status upgraded from community/best-effort to officially supported.
+- **Documentation rewritten** — available at [dcr.dexoron.su/docs](https://dcr.dexoron.su/docs) or in the `docs/` directory. Installation guides, commands, and reference updated to reflect current CLI and config format.
+- **Site rewritten** — `dcr-site` migrated to Docusaurus with internationalization (i18n) support, improved navigation, and updated content across all sections.
+- **Dev channel dependency check in `install.sh`** — checks for `python3` or `jq` before attempting dev channel installations.
+
+Fixed:
+
+- **`dcr run` stdout/stderr not inherited** — child process output was captured and manually printed, breaking interactive programs. Fixed by switching to `Command::status()`.
+- **Release CI race condition** — build matrix jobs could upload assets to a release that did not yet exist. Fixed by adding a dedicated `create-release` job.
+- **GHA release — stable toolchain override** — resolved Rust toolchain override issues in CI.
+- **Arch Linux package version sanitization** — version strings with dashes (e.g. `0.7.0-dev`) are invalid for Arch Linux `pkgver`. Fixed by replacing dashes with dots.
+- **GPG permissions after Docker** — Docker operations changed GPG directory ownership. Fixed by running `chown` after Docker commands.
+- **RPM package artifact paths** — RPM artifacts placed under `rpm/x86_64/` instead of `fedora/x86_64/`. Corrected in Dexoron Packages Index workflow.
+- **`install.sh` JSON parsing robustness** — added `jq` as primary parser with `python3` fallback for dev channel release lookups.
+
+Removed:
+
+- **`format_roots()` helper** — removed from `common.rs`. Was only used by the old error path in `collect_sources()`.
+- **Individual per-distro artifact download steps** — three separate `actions/download-artifact` steps replaced with unified `gh release download --clobber`.
+
+## [0.6.9] - 2026-05-28
+
+Added:
+
+- **Dexoron Packages Index** — new standalone CI workflow (`.github/workflows/dexoron-packages-index.yml`)
+  that automatically updates the `dexoron/packages` repository indexes after a release.
+  Supports Arch Linux (`repo-add`), Debian (`dpkg-scanpackages`), and Fedora (`createrepo_c`).
+  Triggered by `workflow_dispatch` or `workflow_run` on the Release workflow.
+
+- **Arch Linux native package** (`.pkg.tar.zst`) build inside the release workflow —
+  builds from source in an `archlinux:latest` Docker container using a dynamically
+  generated PKGBUILD.
+
+- **AUR publish support** — new `run_aur` workflow dispatch input and `publish-aur` /
+  `publish-aur-bin` jobs that push PKGBUILD / `.SRCINFO` to `aur.archlinux.org`.
+
+Changed:
+
+- **Release workflow refactored** — Linux packages (deb, rpm, snap, arch) and BSD
+  builds now use `strategy.matrix` instead of separate jobs. A new
+  `publish-dexoron-packages` job collects all package artifacts and uploads them
+  to the GitHub Release in one step. Removed standalone `build-arch-package`,
+  `build-snap`, `build-deb-rpm` jobs. The old `run_arch_native` input is now
+  `run_linux_packages`.
+
+- **Dexoron Packages Index workflow** extracted from `release.yml` into its own
+  file with support for Debian and RPM repository indexes in addition to Arch.
+
+- **git2 vendoring** — enabled `vendored-libgit2` and `vendored-openssl` features
+  for reproducible CI builds without system libraries.
+
+- **cargo-generate-rpm metadata** — updated to the current `package.metadata.rpm`
+  format (uses `files` table instead of `assets` array).
+
+Fixed:
+
+- **`--target=<triple>` no longer passed to GCC** — the flag is now only injected into
+  cflags when the resolved compiler name contains `"clang"`. GCC rejects this flag
+  with `unrecognized command-line option`.
+
+- **Workspace clean test** — removed assertions for member-local `target/`
+  directories. Workspace members share the root `target/` directory, so their
+  individual `src/<name>/target/` is never created.
+
+- **Release build test path** — corrected expected directory from `target/release`
+  to `target/x86_64-unknown-linux-gnu/release`.
+
+## [0.6.8] - 2026-05-27
+
+Added:
+
+- `build.cxx_standard` — separate C++ language standard for `.cpp`/`.cxx`/`.cc` files.
+  When set, overrides `build.standard` for C++ sources. Example:
+
+  ```toml
+  [build]
+  language = ["c", "c++"]
+  standard = "gnu11"
+  cxx_standard = "gnu++17"
+  ```
+
+- Variable substitution for `cflags`, `ldflags`, and `include` directory entries.
+  All `{version}`, `{version_major}`, `{name}`, `{profile}` and other step variables
+  are now available. Example:
+
+  ```toml
+  [build]
+  cflags = ['-DPROJECT_VERSION="{version}"']
+  ```
+
+- FreeBSD build support in CI — new `run_bsd` workflow input and `build-bsd` job
+  that cross-compiles `x86_64-unknown-freebsd` via `cargo-zigbuild`.
+
+Changed:
+
+- License changed from MIT to **GPL-3.0-or-later**. All source files now carry
+  the GPL-3.0 header. Default license in `dcr new` / `dcr init` changed to
+  `"GPL-3.0-or-later"`. README, FAQ, and CONTRIBUTING.md updated accordingly.
+- `get_list_with_profile_and_target` no longer duplicates list values when
+  `inherit = true` and the profile/target value is identical to the base value.
+
+Fixed:
+
+- Multi-language `language` array (e.g. `["c", "c++", "asm"]`) no longer drops `c++`
+  during internal parsing — `.cxx`/`.cpp`/`.cc` source files are correctly discovered
+  and compiled.
+- `-std=` flag is no longer passed to C++ files when only `standard` (C standard) is
+  configured — uses `cxx_standard` when available, otherwise skips `-std=` for C++
+  sources, avoiding clang error `invalid argument '-std=c11' not allowed with 'C++'`.
+- Object file collision: source files with the same stem but different extensions
+  (e.g. `gdt.cxx` and `gdt.S`) no longer overwrite each other. Object filenames
+  now include the original source extension (e.g. `gdt.cxx.o`, `gdt.S.o`).
+- MSVC backend compile step now detects language per source file extension instead
+  of using the global `language` field, fixing mixed C/C++ compilation with MSVC.
+- Assembler `-x` flag in `unix_cc.rs` and `gen.rs` is now placed **before** the
+  source file, as required by clang/gcc.
+- `{version}` variables in `build.clean` are now correctly substituted.
+
+## [0.6.7] - 2026-05-26
+
+Added:
+
+- `build.kind = "efi"` — UEFI PE32+ executable support. Links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10`, output via `efi_path()` with `.efi` extension, rejected by `dcr run`.
+- `build.kind = "elf"` — bare-metal ELF executable support. Uses `elf_path()` output path, rejected by `dcr run`, no extra linker flags.
+- `build.filename` and `build.extension` in `dcr.toml` — complete control over the final artifact name without relying on `package.name`.
+  Example:
+
+  ```toml
+  [build]
+  filename = "KERNEL"
+  extension = "EFI"
+  ```
+
+  Produces `KERNEL.EFI` (works for `bin`, `staticlib`, and `sharedlib`).
+- Automatic injection of `--target=<build.target>` into compiler flags when `build.target` is set in `dcr.toml`. This greatly simplifies clang-based cross-compilation (especially for bare-metal targets like `aarch64-none-elf`).
+- Bare-metal targets (containing `none`, `-elf`, `eabi`, `baremetal`) no longer receive DCR's internal default flags (`-g`, `-Wall`, `-Wextra`, `-fno-omit-frame-pointer`, `-DDCR_DEBUG`, etc.). Prevents unwanted sections (`.comment`, debug info, etc.) that break custom linker scripts when `inherit = true`.
+- `build.ldscript` in `dcr.toml` — linker script path passed as `-T <path>` to the linker. Essential for bare-metal/embedded/freestanding targets.
+- `dcr build --verbose` — prints compiler/linker command lines (also works with `DCR_DEBUG` env var).
+- `dcr add <name>` without a source argument — if a registry is configured, DCR looks up the package by name and adds it as a version dependency.
+
+Fixed:
+
+- `build.target` declared in `dcr.toml` is now correctly used as the default target even when `--target` is not passed on the command line (previously the host target was always forced for config resolution).
+- `dcr run` with `--target` or `build.target` now correctly finds the binary in the arch-specific target directory.
+- `dcr run` checks profile-specific `build.{profile}.kind` before rejecting library builds (previously only checked `build.kind`).
+- `dcr clean` now reads `build.target` from `dcr.toml` when no `--target` flag is given.
+- Linux: target directory is now consistent — `target/<arch>-unknown-linux-gnu/<profile>/` (no stale `target/<profile>/`).
+- `dcr.lock` is now populated with all resolved dependencies (registry, path, git) instead of being always empty.
+- Git dependencies are now properly recognized and recorded in `dcr.lock`.
+- `is_registry_dep` correctly identifies version-based registry dependency tables (`{ version = "..." }`) and rejects tables with unknown keys.
+- `dcr test` accepts `--debug`/`--release` flags (defaults to `debug` profile instead of always `release`).
+- Build fingerprint cache (`build_cache_path`) now includes `target_dir` — different targets no longer share a single cache entry.
+- `object_path` no longer hardcodes the `src/` prefix — works correctly with custom `build.roots` (e.g. `roots = ["lib"]`).
+- `dcr update` now generates `.exe` candidates for all Windows targets, not just `x86_64-pc-windows-msvc`.
+- Compiler existence is verified before starting the build (clear error if compiler is not found in PATH).
+- Consolidated duplicate `OUTPUT_MUTEX` definitions — MSVC backend now uses the shared mutex from `common.rs`.
+- Registry cache root directory is created if missing (prevents cryptic errors when `~/.dcr/` does not exist).
+
+Changed:
+
+- `openssl` dependency is now conditional (`cfg(not(windows))`) — no longer pulled in on Windows, fixing Windows CI builds that lack Perl `Locale::Maketext::Simple`. On Linux (including musl cross-compilation) the vendored OpenSSL build is unchanged.
+
+## [0.6.6] - 2026-05-18
+
+Fixed:
+
+- Path dependencies now work correctly: `dcr add` stores them as `{ path =
+"./..." }` tables, `is_registry_dep` properly distinguishes registry strings
+from path/git strings, and `deps/mod.rs` resolves both table-form and
+legacy string-form path dependencies
+- Registry dependency paths no longer hardcoded to `project_root/dcr-index`;
+now use `package_root_from_registry_info()` which resolves relative to the
+registry cache root (`~/.dcr/`)
+- Registry dependencies are now actually built: `build_project_at()` is
+called when `include_dir` or `lib_dir` is missing
+
+Added:
+
+- `SIGINT`/`Ctrl+C` handler via `ctrlc` crate — `dcr build` now checks
+`BUILD_INTERRUPTED` flag at key points and aborts cleanly
+- `utils/build.rs` — extracted shared utilities: `parse_version_info`,
+`normalize_target_os`, `resolve_compiler`, `primary_language`,
+`resolve_pkg_config_flags` and config helpers. Eliminates code duplication
+between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
+- `utils/fs.rs::with_dir` — extracted common directory-scoped execution
+- `run_command_sync_output` in `builder/common.rs` with global `OUTPUT_MUTEX`
+— synchronized compiler output across all backends (unix_cc, gas, nasm, msvc)
+- New helper functions in `deps/register.rs`: `get_registry_cache_root`,
+`package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
+`path_from_string_dep`
+- Unit tests for `register.rs` (`is_registry_dep`, `package_root_from_registry_info`),
+  `deps/mod.rs` (`path_dep_path`, `push_default_lib_dirs`),
+  `utils/build.rs` (`normalize_target_os`, `parse_version_info`)
+- `dcr tree` command — visual dependency tree viewer (similar to `cargo tree`)
+
+Removed:
+
+- Removed unused dependencies `indicatif` and `console` from `Cargo.toml`
+
+## [0.6.5] - 2026-05-13
+
+Added:
+
+- New dependency registry system
+- Package type support (`lib`, `app`, `none`) in `dcr.toml`
+- Library packaging functionality: automatically generates `include` and `lib` directories in `target/` for `lib` type projects
+- Expanded CI build targets:
+  - Linux: `aarch64-unknown-linux-gnu`, `x86_64-unknown-linux-musl`, `aarch64-unknown-linux-musl`
+  - Windows: `aarch64-pc-windows-msvc`, `x86_64-pc-windows-gnu`, `aarch64-pc-windows-gnullvm`
+
+Changed:
+
+- `src/core/deps/` modular architecture overhaul
+- Native platform pathing defaults for Linux (now dynamic architecture detection)
+- Improved `run` command output handling
+
+## [0.6.0] - 2026-05-12
+
+Added:
+
+- Full Git dependency support in `dcr.toml`
+  - Support for `git`, `branch`, `tag`, and `rev` fields
+  - Automatic cloning and checkout via `git2`
+  - Dependencies are stored in `target/<profile>/deps/git/`
+- New `dcr add` command for easy dependency management
+  - Short syntax: `github:user/repo`, `gitlab:user/repo`, `path:/to/lib`
+  - Automatic GitHub resolution for `git:user/repo`
+- Visual feedback for dependency fetching with in-place status updates ("Fetching" → "Fetched")
+- Modular dependency management architecture in `src/core/deps/`
+
+## [0.5.1] - 2026-04-12
+
+Fixed:
+
+- Windows compatibility for target-specific config without --target flag
+
+Added:
+
+- Default host target detection for automatic target overrides
+- Unit tests for target normalization
+
+Improved:
+
+- Config value lookup optimization
+- Documentation for Windows cross-compilation
+
+## [0.5.0] - 2026-04-10
+
+Added:
+
+- Full inheritance system for all config sections: `build`, `toolchain`, `run`, `workspace`, `dependencies`
+  - Order: `section.target.profile` → `section.profile.target` → `section.target` → `section.profile` → `section`
+  - `inherit = false` to disable inheritance completely
+  - Target-specific overrides: `[build.linux]`, `[toolchain.windows]`, `[run.macos]`, etc.
+- Cross-compilation support with `--target <triple>`
+  - Full target triples and short names (`linux`, `macos`, `windows`)
+  - Target-specific config sections: `[build.<target>]`, `[toolchain.<target>]`, `[run.<target>]`
+- Workspace and dependencies support target/profile inheritance
+- Multiple targets build: `[build.targets]` to build for multiple targets simultaneously
+- Target directory structure: `target/<target>/<profile>/` (native or triple)
+- Updated documentation with cross-compilation guide and Arch Linux examples
+
+## [0.4.0] - 2026-04-10
+
+Added:
+
+- Test command: `dcr test` and `dcr tests`
+  - Automatic compilation and linking for tests without manual configuration
+  - `dcr test --init` creates test template and header
+  - Test framework with EXPECT/SKIP macros in `dcr_test.h`
+- Improved test integration: added test CLI module and basic test suite
+- Documentation updates for testing functionality
+
+## [0.3.0] - 2026-03-18
+
+Added:
+
+- `dcr gen` command for IDE integration and build tool support
+- - `dcr gen project-info`: Output project metadata as JSON
+- - `dcr gen compile-commands`: Generate `compile_commands.json` for clangd and clang-tidy
+- - `dcr gen vscode`: Generate VS Code `.vscode/` integration (launch.json, tasks.json, settings.json)
+- - `dcr gen clion`: Generate JetBrains CLion `.idea/` integration (run configurations, build targets)
+- Full workspace support for all `gen` subcommands
+
+## [0.2.10] - 2026-03-16
+
+Added:
+
+- `build.steps` for pre-build generators (e.g., `moc`/`uic`/`rcc`)
+- `build.pkg_config` for `pkg-config`-driven cflags/ldflags resolution
+- `[toolchain]` support for `uic`, `moc`, `rcc`
+- Step command variables (`{uic}`, `{moc}`, `{rcc}`, `{cflags}`, `{stem}`, `{in}`, `{out}`)
+- `{profile}` placeholder support for dependency paths
+
+## [0.2.9] - 2026-03-14
+
+Added:
+
+- Header dependency tracking for fine-grained incremental builds (rebuilds when `#include` files change)
+- Complete internal rewrite of the builder module: merged duplicate compilation backends
+
+Changed:
+
+- `cflags` and `default_flags` no longer incorrectly leak to the linker stage in GCC/Clang
+- Reduced builder codebase size by over 20% while increasing reliability
+- Greatly expanded test suite with 34 new tests covering configuration, CLI errors, and path operations
+
+## [0.2.8] - 2026-03-06
+
+Added:
+
 - Workspace support (`[workspace]` with deps ordering)
 - `clean --all` for workspace members
-Changed:
+  Changed:
 - Project root discovery for `build/run/clean` (searches parent dirs)
 - Workspace paths are excluded from root source scan
 - Build output now uses a Cargo-style `Compiling <name> v<version>` line
@@ -13,12 +348,16 @@ Changed:
 - Safer build cache: fingerprints include headers and resolved library files
 
 ## [0.2.7] - 2026-03-03
+
 Added:
+
 - Toolchain overrides via `[toolchain]` and env (`DCR_*`)
 - ASM `.S` preprocessing via GCC/Clang (`-x assembler-with-cpp`)
 
 ## [0.2.6] - 2026-03-01
+
 Added:
+
 - `sharedlib` build kind (shared library output)
 - ASM projects (`build.language = "asm"`)
 - NASM and GAS backends
@@ -26,24 +365,31 @@ Added:
 - Basic CLI integration tests
 
 ## [0.2.5] - 2026-02-26
+
 Added:
+
 - Incremental builds (object caching by mtime)
 - `build.kind` with `staticlib` support
 - Custom output directory via `build.target`
 
 ## [0.2.4] - 2026-02-22
+
 Added:
+
 - Custom build flags: `build.cflags` and `build.ldflags`
 - Recursive source discovery inside `src/`
 - Path dependencies with auto include/lib resolution and `dcr.lock` generation (experimental)
 - Add docs/index.md and docs/dcr-toml.md
 
 ## [0.2.3] - 2026-02-21
+
 Added:
+
 - Modular builders for `gcc`, `clang`, `msvc`
 - Platform-specific binary path generation (Linux/macOS/Windows)
 
 Changed:
+
 - Build configuration moved to `[build]` (`language`, `standard`, `compiler`)
 - `dcr.toml` formatting now includes the `[build]` section
 - Build uses built-in `debug/release` flags per compiler
@@ -51,20 +397,26 @@ Changed:
 - Updated `dcr.toml` examples in documentation
 
 ## [0.2.2] - 2026-02-20
+
 Changed:
+
 - Reworked `dcr.toml` handling: added read, validation, and edit through `core::config`
 - `new` and `init` use the new config creation logic
 - `build` and `run` now require `dcr.toml` and read `compiler` and `name` from it
 
 ## [0.2.1] - 2026-02-18
+
 Changed:
+
 - Translated user-facing CLI messages to English
 - Unified error and warning output via `utils::log::{error, warn}`
 - Updated `--help` output: translated headers and examples to English, used `printc`, and applied `BOLD_*` styles
 - Translated installer script messages in `install.sh` and `install.ps1` to English
 
 ## [0.2.0] - 2026-02-17
+
 Changed:
+
 - Project migrated from Python to Rust
 - CLI and commands (`new`, `init`, `build`, `run`, `clean`, `--help`, `--version`, `--update`) ported to Rust
 - Updated `--update` flag: added support for GNU/Linux, Windows, macOS
@@ -73,31 +425,40 @@ Changed:
 - Updated `install.sh` for GNU/Linux and macOS
 
 Added:
+
 - Added `install.ps1` for Windows
 - Support for GNU/Linux, Windows, macOS (x86_64/arm)
 
 Important:
+
 - Code was ported with neural networks; future versions will include bug fixes and logic changes
 
 ## [0.1.2] - 2026-02-12
+
 Added:
+
 - Update command
 - `install.sh` install script and README instructions
 - `--version` flag
 
 Changed:
+
 - Improved CLI output, added colors, and updated `--help`
 - Updated project run/build handling in `run.py`/`build.py`
 
 ## [0.1.1] - 2026-02-11
+
 Changed:
+
 - Updated `--help`
 - `main.py` now runs correctly when executed directly
 
 ## [0.1.0] - 2026-02-11
+
 First public release.
 
 Added:
+
 - Base commands `new`, `init`, `build`, `run`, `clean`
 - Build profiles `debug` and `release`
 - `dcr.toml` and `src/main.c` templates

CONTRIBUTING.md

@@ -22,6 +22,29 @@ cargo check
 - Keep functions small and focused.
 - Prefer clear names over clever ones.
 
+## Target System
+
+DCR supports cross-compilation via `--target <triple>` or short names:
+
+- `dcr build --target linux --release` (maps to `x86_64-unknown-linux-gnu`)
+- `dcr build --target macos --release` (maps to `x86_64-apple-darwin`)
+- `dcr build --target windows --release` (maps to `x86_64-pc-windows-msvc`)
+- Full triples: `dcr build --target aarch64-linux-gnu --release`
+- Configure multiple targets in `dcr.toml`:
+
+  ```toml
+  [build]
+  targets = ["linux", "macos"]
+
+  [build.linux]
+  compiler = "gcc"
+
+  [build.macos]
+  compiler = "clang"
+  ```
+
+- If no `--target`, builds for targets in `build.targets` or native if empty.
+
 ## Checks
 
 Before PR, run:
@@ -49,10 +72,15 @@ cargo test
 - In PRs, include a short description and rationale.
 - Update documentation when behavior changes.
 
+## License
+
+This project is licensed under the **GNU General Public License v3.0**. By contributing, you agree that your contributions will be licensed under the same license.
+
 ## Questions
 
 If anything is unclear, open an issue or ask in the PR.
 
 You can also reach out directly:
+
 - TG: @dexoron
 - DS: dexoron

Cargo.toml

@@ -1,12 +1,58 @@
 [package]
 name = "dcr"
-version = "0.2.8"
+version = "0.7.0"
 edition = "2024"
 build = "build.rs"
+description = "DCR is a utility for managing C/C++ projects in a Cargo-like style."
+license = "GPL-3.0-or-later"
+repository = "https://github.com/dexoron/dcr"
+
+[package.metadata.binstall]
+pkg-fmt = "bin"
+pkg-url = "{ repo }/releases/download/v{ version }/dcr-{ target }-{ version }{ bin-suffix }"
+
+[package.metadata.deb]
+maintainer = "Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>"
+copyright = "2026, Dexoron"
+extended-description = """
+Cargo-like utility to manage C/C++ projects.
+"""
+section = "devel"
+priority = "optional"
+assets = [
+    ["target/release/dcr", "usr/bin/dcr", "755"],
+]
+
+[package.metadata.generate-rpm]
+summary = "Cargo-like utility to manage C/C++ projects"
+description = """
+Cargo-like utility to manage C/C++ projects.
+"""
+
+assets = [
+    { source = "target/release/dcr", dest = "/usr/bin/dcr", mode = "755" }
+]
 
 [dependencies]
+glob = "0.3"
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
 self-replace = "1"
 sha2 = "0.10"
 toml = "1.0.3"
+serde_json = "1"
+ctrlc = "3"
+
+[target.'cfg(not(windows))'.dependencies]
+git2 = { version = "0.20.4", features = ["vendored-libgit2", "vendored-openssl"] }
+openssl = { version = "0.10", features = ["vendored"] }
+
+[target.'cfg(windows)'.dependencies]
+git2 = { version = "0.20.4", features = ["vendored-libgit2"] }
+
+[profile.release]
+opt-level = "z"
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = true

FAQ.md

@@ -1,38 +1,46 @@
 # FAQ
 
 ## What is this project about?
+
 `dcr` is a tool for managing C/C++ projects and their dependencies.
 It is inspired by Cargo, but it is not a direct equivalent of Makefile, CMake, or other classic build systems.
 
 The goal is to provide a simpler and easier-to-configure development workflow.
 
 ## How is the project developed?
+
 The project is written in Rust and is primarily developed by one maintainer, Dexoron.
 
 AI tools are used during development, but they do not write the project end-to-end. Their role is limited to supporting specific tasks (for example, suggestions, wording checks, and translations).
 
 ## Which tools are used for development?
+
 Main development stack:
+
 - `RustRover` 2025 - development IDE.
 - `Codex` (`GPT-5.3-Codex (medium)`) - primary AI tool, integrated via JetBrains AI Chat.
 - `Rust` - main project language.
 - `Cargo` - tool for building, testing, and dependency management in Rust projects.
 
 ## Is the project open source?
+
 Yes, the project is open source.
 You can propose ideas, report issues, and contribute code changes.
 
-The project is distributed under the MIT license (see `LICENSE`).
+The project is distributed under the GPL-3.0 license (see `LICENSE`).
 
 ## How can I contribute?
+
 Thank you for contributing.
 You can:
+
 - help with code;
 - help with translations;
 - help with documentation;
 - suggest an idea or report a bug.
 
 ### If you want to submit changes (code, translation, documentation)
+
 1. Fork the required repository: `dexoron/dcr` (main project) or `dexoron/dcr-site` (project website).
 2. Make your changes following the rules in `CONTRIBUTING.md`.
 3. Push changes to your fork.
@@ -40,6 +48,7 @@ You can:
 5. Wait for review.
 
 ### If you want to report a problem or suggest an idea
+
 1. Open the relevant repository: `dexoron/dcr` or `dexoron/dcr-site`.
 2. Go to the `Issues` tab.
 3. Create an Issue and specify its type (bug, suggestion, question/help).
@@ -47,13 +56,17 @@ You can:
 5. Wait for feedback.
 
 ## How do I install `dcr`?
+
 Available installation methods may vary by project version.
 Recommended path:
+
 - check instructions in `README.md`;
 - if there is no prebuilt package for your platform, build from source using `cargo build --release`.
 
 ## How can I get started quickly?
+
 Minimal workflow:
+
 1. Install `dcr`.
 2. Create a project (or open an existing C/C++ project).
 3. Initialize `dcr` configuration.
@@ -63,21 +76,25 @@ Minimal workflow:
 For detailed commands and examples, see `README.md` and the project documentation.
 
 ## What is the project status?
+
 `dcr` is under active development.
 This means some interfaces and behaviors may change between versions.
 
 Before upgrading, check the changelog and release notes.
 
 ## Which systems does `dcr` support?
+
 `dcr` targets modern C/C++ development environments.
 Actual compatibility depends on the `dcr` version, operating system, and toolchain.
 
 Before starting, check documentation for:
+
 - supported operating systems;
 - supported compilers and linkers;
 - version-specific limitations.
 
 ## How is `dcr` different from Make/CMake?
+
 `dcr` does not aim to be a direct replacement for Make/CMake.
 Its main focus is simplifying project and dependency management with a Cargo-like experience.
 
@@ -85,13 +102,17 @@ If you need low-level, full control over build steps, classic tools may be a bet
 If you want a simpler and more uniform configuration model, `dcr` may be more convenient.
 
 ## Where can I find documentation and examples?
+
 Primary sources:
+
 - `README.md` in the repository;
 - project documentation (see the project website);
 - `Issues` for known problems and discussions.
 
 ## How do I report a bug properly?
+
 To make a bug report easy to reproduce, include:
+
 1. `dcr` version.
 2. OS and compiler/toolchain version.
 3. Steps to reproduce.

LICENSE

@@ -1,21 +1,675 @@
-MIT License
+# GNU GENERAL PUBLIC LICENSE
 
-Copyright (c) 2026 Dexoron (Bezotechestvo Vladimir) [main@dexoron.su]
+Version 3, 29 June 2007
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+Copyright (C) 2007 Free Software Foundation, Inc.
-of this software and associated documentation files (the "Software"), to deal
+<https://fsf.org/>
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+Everyone is permitted to copy and distribute verbatim copies of this
-copies or substantial portions of the Software.
+license document, but changing it is not allowed.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+## Preamble
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+The GNU General Public License is a free, copyleft license for
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+software and other kinds of works.
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+The licenses for most software and other practical works are designed
-SOFTWARE.
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom
+to share and change all versions of a program--to make sure it remains
+free software for all its users. We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies
+also to any other work released this way by its authors. You can apply
+it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you
+have certain responsibilities if you distribute copies of the
+software, or if you modify it: responsibilities to respect the freedom
+of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the
+manufacturer can do so. This is fundamentally incompatible with the
+aim of protecting users' freedom to change the software. The
+systematic pattern of such abuse occurs in the area of products for
+individuals to use, which is precisely where it is most unacceptable.
+Therefore, we have designed this version of the GPL to prohibit the
+practice for those products. If such problems arise substantially in
+other domains, we stand ready to extend this provision to those
+domains in future versions of the GPL, as needed to protect the
+freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish
+to avoid the special danger that patents applied to a free program
+could make it effectively proprietary. To prevent this, the GPL
+assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+## TERMS AND CONDITIONS
+
+### 0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of
+an exact copy. The resulting work is called a "modified version" of
+the earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user
+through a computer network, with no transfer of a copy, is not
+conveying.
+
+An interactive user interface displays "Appropriate Legal Notices" to
+the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+### 1. Source Code.
+
+The "source code" for a work means the preferred form of the work for
+making modifications to it. "Object code" means any non-source form of
+a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can
+regenerate automatically from other parts of the Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same
+work.
+
+### 2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey,
+without conditions so long as your license otherwise remains in force.
+You may convey covered works to others for the sole purpose of having
+them make modifications exclusively for you, or provide you with
+facilities for running those works, provided that you comply with the
+terms of this License in conveying all material for which you do not
+control copyright. Those thus making or running the covered works for
+you must do so exclusively on your behalf, under your direction and
+control, on terms that prohibit them from making any copies of your
+copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the
+conditions stated below. Sublicensing is not allowed; section 10 makes
+it unnecessary.
+
+### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such
+circumvention is effected by exercising rights under this License with
+respect to the covered work, and you disclaim any intention to limit
+operation or modification of the work as a means of enforcing, against
+the work's users, your or third parties' legal rights to forbid
+circumvention of technological measures.
+
+### 4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+### 5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these
+conditions:
+
+-   a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+-   b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under
+    section 7. This requirement modifies the requirement in section 4
+    to "keep intact all notices".
+-   c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy. This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged. This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+-   d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+### 6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of
+sections 4 and 5, provided that you also convey the machine-readable
+Corresponding Source under the terms of this License, in one of these
+ways:
+
+-   a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+-   b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the Corresponding
+    Source from a network server at no charge.
+-   c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+-   d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source. Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+-   e) Convey the object code using peer-to-peer transmission,
+    provided you inform other peers where the object code and
+    Corresponding Source of the work are being offered to the general
+    public at no charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal,
+family, or household purposes, or (2) anything designed or sold for
+incorporation into a dwelling. In determining whether a product is a
+consumer product, doubtful cases shall be resolved in favor of
+coverage. For a particular product received by a particular user,
+"normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the way
+in which the particular user actually uses, or expects or is expected
+to use, the product. A product is a consumer product regardless of
+whether the product has substantial commercial, industrial or
+non-consumer uses, unless such uses represent the only significant
+mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to
+install and execute modified versions of a covered work in that User
+Product from a modified version of its Corresponding Source. The
+information must suffice to ensure that the continued functioning of
+the modified object code is in no case prevented or interfered with
+solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or
+updates for a work that has been modified or installed by the
+recipient, or for the User Product in which it has been modified or
+installed. Access to a network may be denied when the modification
+itself materially and adversely affects the operation of the network
+or violates the rules and protocols for communication across the
+network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+### 7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders
+of that material) supplement the terms of this License with terms:
+
+-   a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+-   b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+-   c) Prohibiting misrepresentation of the origin of that material,
+    or requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+-   d) Limiting the use for publicity purposes of names of licensors
+    or authors of the material; or
+-   e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+-   f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions
+    of it) with contractual assumptions of liability to the recipient,
+    for any liability that these contractual assumptions directly
+    impose on those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions; the
+above requirements apply either way.
+
+### 8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+### 9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run
+a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+### 10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+### 11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned
+or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the
+scope of its coverage, prohibits the exercise of, or is conditioned on
+the non-exercise of one or more of the rights that are specifically
+granted under this License. You may not convey a covered work if you
+are a party to an arrangement with a third party that is in the
+business of distributing software, under which you make payment to the
+third party based on the extent of your activity of conveying the
+work, and under which the third party grants, to any of the parties
+who would receive the covered work from you, a discriminatory patent
+license (a) in connection with copies of the covered work conveyed by
+you (or copies made from those copies), or (b) primarily for and in
+connection with specific products or compilations that contain the
+covered work, unless you entered into that arrangement, or that patent
+license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+### 12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under
+this License and any other pertinent obligations, then as a
+consequence you may not convey it at all. For example, if you agree to
+terms that obligate you to collect a royalty for further conveying
+from those to whom you convey the Program, the only way you could
+satisfy both those terms and this License would be to refrain entirely
+from conveying the Program.
+
+### 13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+### 14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in
+detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies that a certain numbered version of the GNU General Public
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that numbered version or
+of any later version published by the Free Software Foundation. If the
+Program does not specify a version number of the GNU General Public
+License, you may choose any version ever published by the Free
+Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions
+of the GNU General Public License can be used, that proxy's public
+statement of acceptance of a version permanently authorizes you to
+choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+### 15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+### 16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
+CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
+NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
+LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
+PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+### 17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+## How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+To do so, attach the following notices to the program. It is safest to
+attach them to the start of each source file to most effectively state
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+        <one line to give the program's name and a brief idea of what it does.>
+        Copyright (C) <year>  <name of author>
+
+        This program is free software: you can redistribute it and/or modify
+        it under the terms of the GNU General Public License as published by
+        the Free Software Foundation, either version 3 of the License, or
+        (at your option) any later version.
+
+        This program is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+
+        You should have received a copy of the GNU General Public License
+        along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+        <program>  Copyright (C) <year>  <name of author>
+        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+        This is free software, and you are welcome to redistribute it
+        under certain conditions; type `show c' for details.
+
+The hypothetical commands \`show w' and \`show c' should show the
+appropriate parts of the General Public License. Of course, your
+program's commands might be different; for a GUI interface, you would
+use an "about box".
+
+You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. For more information on this, and how to apply and follow
+the GNU GPL, see <https://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your
+program into proprietary programs. If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library. If this is what you want to do, use the
+GNU Lesser General Public License instead of this License. But first,
+please read <https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,136 +1,172 @@
-# DCR (Dexoron Cargo Realization)
+<div align="center">
 
-DCR is a utility for managing C/C++ projects in a Cargo-like style.
+# DCR — Dexoron Cargo Realization
 
-The current implementation is written in Rust.
+**A Cargo-style build tool for C/C++ projects**
 
-## Why DCR
+[![CI](https://github.com/dexoron/dcr/actions/workflows/ci.yml/badge.svg)](https://github.com/dexoron/dcr/actions/workflows/ci.yml)
-- Unified project structure without manual setup
+[![GitHub Release](https://img.shields.io/github/v/release/dexoron/dcr)](https://github.com/dexoron/dcr/releases/latest)
-- Simple commands for common tasks
+[![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/dexoron/dcr/releases)
-- Transparent compilation and predictable build profiles
+<br/>
+[![AUR](https://img.shields.io/aur/version/dcr)](https://aur.archlinux.org/packages/dcr)
+[![Crates.io](https://img.shields.io/crates/v/dcr)](https://crates.io/crates/dcr)
+[![Homebrew](https://img.shields.io/badge/homebrew-dexoron%2Fdexoron-orange)](https://github.com/dexoron/homebrew-dexoron)
+<br/>
+[![GitHub Stars](https://img.shields.io/github/stars/dexoron/dcr?style=flat)](https://github.com/dexoron/dcr/stargazers)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](LICENSE)
 
-## Features
+</div>
-- Create a new project or initialize the current directory
-- Build a project with `debug` and `release` profiles
-- Run the compiled binary
-- Clean build artifacts
-- Generate a minimal C project template
-- Build static and shared libraries
-- ASM projects with NASM/GAS or via GCC/Clang
-- Update the binary via `dcr --update` (GitHub Releases, not for pacman/AUR installs)
 
-## Supported Platforms
+---
-- Linux: `x86_64-unknown-linux-gnu`
+
-- macOS Intel: `x86_64-apple-darwin`
+## Why DCR?
-- macOS Apple Silicon: `aarch64-apple-darwin`
+
-- Windows: `x86_64-pc-windows-msvc`
+- **No boilerplate** — one config file, predictable structure
+- **Cargo-like workflow** — `build`, `run`, `clean`, `test`, `add`
+- **Cross-compilation** — full target triple support with short names
+- **IDE integration** — VS Code, CLion, `compile_commands.json` out of the box
+- **Dependencies** — path, git, and registry-based with lock file
+
+---
 
 ## Installation
 
-### Package Manager
+<table>
+<tr>
+<td><b>Linux (Dexoron Packages)</b></td>
+<td>
 
-**Arch Linux**
+See https://dcr.dexoron.su for settings youre packages manager
-```sh
-yay -S dcr # or paru and other AUR package managers
-```
 
-### From Source
+**Arch Linux:**
 
 ```sh
-git clone https://github.com/dexoron/dcr.git
+sudo pacman -Sy dcr
-cd dcr
-cargo build --release
-mkdir -p ~/.local/bin
-ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
 ```
 
-### Via `install.sh` (Linux/macOS)
+**Debian/Ubuntu:**
 
 ```sh
-curl -fsSL https://dcr.dexoron.su/install.sh | bash
+sudo apt update && sudo apt install dcr
 ```
 
-### Via `install.ps1` (Windows)
+**Fedora/RHEL:**
+
+```sh
+sudo dnf install dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Arch Linux (AUR)</b></td>
+<td>
+
+```sh
+yay -S dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>macOS/Linux(GNU) (Homebrew)</b></td>
+<td>
+
+```sh
+brew tap dexoron/dexoron
+brew install dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Nix (flake)</b></td>
+<td>
+
+```sh
+nix run github:dexoron/dcr
+# or install to profile:
+nix profile install github:dexoron/dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Cargo (crates.io)</b></td>
+<td>
+
+```sh
+cargo install dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Linux / macOS (script)</b></td>
+<td>
+
+```sh
+curl -fsSL https://dcr.dexoron.su/install.sh | sh
+```
+
+</td>
+</tr>
+<tr>
+<td><b>BSD (script)</b></td>
+<td>
+
+```sh
+curl -fsSL https://dcr.dexoron.su/install_bsd.sh | sh
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Windows (PowerShell)</b></td>
+<td>
 
 ```powershell
 irm https://dcr.dexoron.su/install.ps1 | iex
 ```
 
-When executed, both scripts ask whether to:
+</td>
-- download a prebuilt binary from GitHub Releases
+</tr>
-- or build the project from `git`
+<tr>
+<td><b>From source</b></td>
+<td>
 
-Release assets:
+```sh
-- `dcr-x86_64-unknown-linux-gnu`
+git clone https://github.com/dexoron/dcr.git
-- `dcr-x86_64-apple-darwin`
+cd dcr && cargo build --release
-- `dcr-aarch64-apple-darwin`
+ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
-- `dcr-x86_64-pc-windows-msvc.exe`
+```
 
-## Update
+</td>
+</tr>
+</table>
 
-- If DCR was installed from GitHub release assets, `install.sh`, `install.ps1`, or built manually:
+---
-  - use `dcr --update`
-- If DCR is installed via `pacman/AUR`:
-  - update with your package manager: `paru/yay -Syu dcr` or `sudo pacman -Syu dcr`
-  - `dcr --update` detects package-managed installs and asks you to update via package manager
 
 ## Quick Start
 
-Create a new project:
+```sh
-`dcr new hello`
+dcr new hello
-
+cd hello
-Or initialize the current directory (the directory must be empty):
+dcr run
-`dcr init`
-
-Project structure:
-
-```txt
-hello/
-- src/
-- - main.c
-- dcr.toml
 ```
 
-Build and run the project:
+**Project structure:**
-`dcr run` or `dcr run --release`
 
-## Commands
+```
+hello/
+├── dcr.toml       # project config
+└── src/
+    └── main.c
+```
 
-### `dcr new <name>`
+---
-Creates a project with the specified name in the current directory.
 
-### `dcr init`
+## dcr.toml Example
-Creates a project in the current directory. The project name is taken from the directory name. The directory must be empty.
-
-### `dcr build [profile]`
-Builds the project. If no profile is specified, `--debug` is used.
-
-### `dcr run [profile]`
-Builds the project and runs the binary. If no profile is specified, `--debug` is used.
-
-Run manually:
-`./target/<profile>/<name>`
-
-### `dcr clean`
-Removes the `target` directory in the project root.
-Use `dcr clean --all` in a workspace root to clean all member projects.
-
-## Build Profiles
-Two profiles are supported:
-- `--debug` (default) - built-in flags per compiler
-- `--release` - built-in flags per compiler
-
-Custom flags can be added in `dcr.toml` via `build.cflags` and `build.ldflags`.
-You can also set `build.target` to override the output directory (profile-independent).
-You can set `build.platform` to pass `-march=<platform>` (GCC/Clang) or `/arch:*` (MSVC) where supported.
-Use `build.kind = "staticlib"` to build a static library instead of a binary.
-Use `build.kind = "sharedlib"` to build a shared library (`.so`/`.dylib`/`.dll`).
-`dcr run` is only for `build.kind = "bin"` and will fail for libraries.
-
-## Configuration
-The main project file is `dcr.toml`.
-
-Example `dcr.toml`:
 
 ```toml
 [package]
@@ -141,42 +177,86 @@ version = "0.1.0"
 language = "c"
 standard = "c11"
 compiler = "clang"
-# Optional platform hint
+kind = "bin"
-# platform = "x86_64"
-# Optional custom flags
-cflags = ["-Wall", "-Wextra"]
-ldflags = ["-lm"]
-
-[toolchain]
-# Optional tool overrides:
-# cc = "clang"
-# cxx = "clang++"
-# as = "as"
-# ar = "ar"
-# ld = "ld"
 
 [dependencies]
 ```
 
-Workspace example:
+---
 
-```toml
+## Base Commands
-[workspace]
+
-kernel = { path = "src/kernel", deps = ["core", "userspace"] }
+| Command | Description |
-core = { path = "src/core", deps = ["userspace"] }
+|---|---|
-userspace = { path = "src/userspace" }
+| `dcr new <name>` | Create a new project |
+| `dcr init` | Initialize current directory |
+| `dcr add <dep>` | Add a dependency |
+| `dcr build [--release]` | Build the project |
+| `dcr run [--release]` | Build and run |
+| `dcr clean` | Remove build artifacts |
+| `dcr test` | Run project tests |
+| `dcr fmt` | Format C/C++ sources (clang-format) |
+| `dcr tree` | View dependency tree |
+| `dcr gen <vscode\|clion\|compile-commands>` | Generate IDE integration |
+| `dcr setup` | Initialize DCR registry |
+
+other in [docs/](docs/) and `dcr --help`
+
+---
+
+## Platforms(pre-build source)
+
+<div align="center">
+
+| OS | x86_64 | aarch64 | armv7 | i686 | riscv64 | GNU | Musl | MSVC | MinGW |
+|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| Linux   | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ | ❌ |
+| macOS   | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Windows | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+| FreeBSD | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
+| OpenBSD | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
+| NetBSD  | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
+
+✅ officially supported · ⚠️ community / best-effort · ❌ not supported
+
+</div>
+
+---
+
+## Documentation
+
+Full docs at **[dcr.dexoron.su](https://dcr.dexoron.su)** or in the [`docs/`](docs/) directory.
+
+---
+
+## Contributors
+
+<div align="center">
+
+| | Name | Role | GitHub |
+|:---:|---|---|---|
+| 👤 | Dexoron (Bezotechestvo Vladimir) | Maintainer, Creator | [@dexoron](https://github.com/dexoron) |
+| 👤 | Kai | Maintainer | [@peoplemiau1](https://github.com/peoplemiau1) |
+
+</div>
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Before a PR:
+
+```sh
+cargo fmt --all
+cargo clippy --all-targets --all-features -- -D warnings
+cargo test
 ```
 
-Path dependencies are supported. DCR will resolve them on build and generate `dcr.lock`.
+---
 
-Incremental build note: object files are rebuilt when source `.c/.cpp` files change. Header dependency tracking is not implemented yet.
+<div align="center">
 
-## Requirements
+GPL-3.0 — see [LICENSE](LICENSE)<br/>
-- Rust toolchain (`rustc`, `cargo`) - for building DCR from source
+Made with ❤️ by [Dexoron](https://github.com/dexoron) and contributors.
-- C compiler (`clang`, `gcc`, or 'cl'(msvc))
 
-## Releases
+</div>
-Releases are built automatically via GitHub Actions (`.github/workflows/release.yml`) when a tag matching `v*` is pushed.
-
-## License
-See `LICENSE`.

TODO.md

@@ -1,6 +1,69 @@
-# TODO
+# DCR TODO.md
 
-- Add header dependency tracking for incremental builds (GCC/Clang: -MMD, MSVC: /showIncludes)
+Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers.
-- Add external package managers (Conan, vcpkg)
+
-- Linker script + direct linker control
+## 🔥 High Priority (Next Releases)
-- Custom targets/steps
+
+- [x] **Git dependencies support**  
+  `git = "https://github.com/user/repo.git#branch"` and `git = "..."@tag`
+- [ ] **Conan and vcpkg integration**  
+  Automatic download, installation and linking of packages
+- [ ] **Full freestanding / embedded support**  
+  `-nostdlib`, linker scripts, bare-metal targets (i686-elf, aarch64-none-elf, etc.)
+- [ ] **EFI support**  
+  Dedicated platform configuration for EFI targets
+- [ ] **Custom project name**  
+  Override binary name in `dcr.toml`
+- [ ] **Custom build steps / targets**  
+  Ability to define custom pre-build, post-build, codegen steps in `dcr.toml`
+- [ ] **Improved mixed C/C++/ASM projects**  
+  Better handling of `.S` and `.asm` files with correct flags
+- [ ] **dcr publish + official package registry**  
+  Publish and fetch your own libraries easily
+
+## ✅ Medium Priority
+
+- [ ] **Static analysis** (`dcr check`)  
+  Integration with clang-tidy, cppcheck, include-what-you-use
+- [ ] **Linter + Formatter** (`dcr fmt`, `dcr lint`)
+- [ ] **Hot reload / Live reload** for applications (raylib, SFML, SDL, etc.)
+- [ ] **Better cross-compilation experience**  
+  Ready-to-use toolchains + automatic download
+- [ ] **Linker script support** + direct linker control
+- [ ] **Workspaces improvements**  
+  Per-member include directories, selective builds, better dependency graph
+- [ ] **Build-time code generation**  
+  Support for protobuf, flatbuffers, Qt moc, custom generators
+
+## 📌 Low Priority / Nice to Have
+
+- [ ] Support for Meson and Ninja as alternative backends
+- [ ] Dockerfile generation (`dcr docker init`)
+- [ ] First-class Windows MSVC support (currently works but rough)
+- [ ] Documentation generation (`dcr doc`)
+- [ ] Sanitizers integration (`dcr sanitize`)
+- [ ] Benchmarks and comparison with CMake/Meson
+- [ ] C++20 modules support (when it becomes stable)
+
+## 🧠 Future Ideas
+
+- Official DCR package registry (dcrhub)
+- GUI wrapper (dcr-gui)
+- Plugin system
+- Toolchain manager (like rustup)
+- Zig as alternative compiler
+- deb/rpm/flatpak/AppImage packaging support
+
+---
+
+**Currently in progress:**
+
+- ...
+
+**Completed in recent releases:**
+
+- Workspaces
+- Cross-compilation
+- IDE config generation (VS Code, CLion, compile_commands.json)
+- Self-update (`dcr --update`)
+- Header tracking

build.rs

@@ -1,3 +1,20 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 fn main() {
     let target = std::env::var("TARGET").unwrap_or_else(|_| "unknown-target".to_string());
     println!("cargo:rustc-env=DCR_TARGET={target}");

docs/README.md

@@ -1,39 +0,0 @@
-# Introduction
-
-DCR (Dexoron Cargo Realization) is a Cargo-style CLI for C/C++ projects.
-
-Current DCR focuses on a simple, predictable workflow:
-
-- create or initialize a project (`dcr new`, `dcr init`)
-- build with `debug` or `release` profiles (`dcr build`)
-- run binaries (`dcr run`)
-- clean artifacts (`dcr clean`)
-- update the installed binary (`dcr --update`)
-
-## What is implemented in this version
-
-- Project configuration in `dcr.toml` with `[package]`, `[build]`, `[dependencies]`.
-- Recursive source discovery in `src/`:
-  - C: `*.c`
-  - C++: `*.cpp`, `*.cxx`, `*.cc`
-- Compiler selection from `dcr.toml` (`clang`, `gcc`, `cl`, `clang-cl`, etc.).
-- ASM support via `language = "asm"` (GCC/Clang, NASM, GAS).
-- Three build kinds:
-  - `bin` (default)
-  - `staticlib`
-  - `sharedlib`
-- Optional custom output directory via `build.target`.
-- Optional `build.platform` to pass architecture hints (`-march` / `/arch`).
-- Workspace builds via `[workspace]` with per-project `dcr.toml`.
-- Path dependencies with include/lib resolution and `dcr.lock` generation.
-
-## Important behavior notes
-
-- `dcr.toml` is required for `build`, `run`, and `clean`.
-- `run` works only with `build.kind = "bin"`.
-- Incremental rebuild currently tracks source file timestamps (not header dependency graphs).
-- Object files are always created under `target/<profile>/obj/`.
-
-## Repository
-
-- <https://github.com/dexoron/dcr>

docs/README.mdx

@@ -0,0 +1,60 @@
+---
+sidebar_label: Introduction
+---
+
+# DCR — C/C++ Build Tool & Package Manager
+
+<details>
+<summary>Quick reference</summary>
+
+```bash
+# Installation
+curl -fsSL https://dcr.dexoron.su/install.sh | sh
+
+# Create a project
+dcr new my-app
+cd my-app
+
+# Build and run
+dcr build
+dcr run
+
+# Run tests
+dcr test
+
+# Add a dependency
+dcr add fmt
+
+# Generate IDE files
+dcr gen vscode
+```
+
+</details>
+
+## Contents
+
+| Section | Description |
+|---------|-------------|
+| [Getting Started](/docs/getting-started/installation) | Installation and first steps |
+| [Commands](/docs/commands/project-commands) | All CLI commands |
+| [Reference](/docs/reference/dcr-toml) | Configuration, build, dependencies, platforms |
+| [Testing](/docs/testing/test-framework) | Built-in test framework |
+| [Recipes](/docs/recipes/cross-to-windows) | Common scenarios |
+| [IDE Integration](/docs/ide-integration) | VS Code, CLion, compile_commands.json |
+| [Self Update](/docs/self-update) | Auto-update |
+| [FAQ](/docs/faq) | Frequently asked questions |
+| [Changelog](/docs/changelog) | Version history |
+| [Contributing](/docs/contributing) | DCR development |
+
+## Features
+
+- **Incremental builds** — mtime + `.d` headers + SHA256 fingerprint
+- **Parallel compilation** — thread::scope, atomic task queue
+- **4 backends** — gcc/clang, MSVC/clang-cl, GAS (ARM), NASM (x86)
+- **7 project kinds** — bin, staticlib, sharedlib, efi, elf, none, custom
+- **Cross-compilation** — short names and full triples
+- **Profiles** — debug / release with field overrides
+- **Workspaces** — multi-package projects with topological sort
+- **Registry + Git + Path** — three dependency mechanisms
+- **IDE generation** — VS Code, CLion, compile_commands.json, JSON metadata
+- **pkg-config** — automatic system library discovery

docs/SUMMARY.md

@@ -1,41 +0,0 @@
-# Table of contents
-
-* [Introduction](README.md)
-
-## Getting started
-
-* [Installation](getting-started/installation.md)
-* [Create your first project](getting-started/create-your-first-project.md)
-* [Project structure](getting-started/project-structure.md)
-* [Build and run](getting-started/build-and-run.md)
-
-## Configuration
-
-* [dcr.toml overview](configuration/dcr.toml-overview.md)
-* [Package section](configuration/package-section.md)
-* [Build section](configuration/build-section.md)
-* [Dependencies section](configuration/dependencies-section.md)
-* [Build profiles](configuration/build-profiles.md)
-
-## Commands
-
-* [Global options](commands/global-options.md)
-* [dcr init/new](commands/dcr-init-or-new.md)
-* [dcr build](commands/dcr-build.md)
-* [dcr run](commands/dcr-run.md)
-* [dcr clean](commands/dcr-clean.md)
-
-## Dependencies & Build
-
-* [Dependency format](dependencies-and-build/dependency-format.md)
-* [Local dependencies](dependencies-and-build/local-dependencies.md)
-* [Versioning & lock file](dependencies-and-build/versioning-and-lock-file.md)
-* [Target directory](dependencies-and-build/target-directory.md)
-* [Compilers & linking](dependencies-and-build/compilers-and-linking.md)
-
-## Reference & Help
-
-* [CLI reference](reference-and-help/cli-reference.md)
-* [Config reference](reference-and-help/config-reference.md)
-* [FAQ](reference-and-help/faq.md)
-* [Contributing & Bug reports](reference-and-help/contributing-and-bug-reports.md)

docs/changelog.mdx

@@ -0,0 +1,47 @@
+---
+sidebar_label: Changelog
+---
+
+# Changelog
+
+## 0.7.0 (2026-06-01)
+
+### Added
+
+- **OpenBSD and NetBSD target support** — full platform routing with dynamic target triples using `std::env::consts::ARCH` and `std::env::consts::OS`. Affects `build`, `run`, `clean` commands and the platform module.
+- **`src/platform/bsd.rs`** — new BSD platform module (shared by FreeBSD, OpenBSD, NetBSD) providing `bin_path`, `lib_path`, `elf_path`, `efi_path`, `shared_lib_path`.
+- **`build.out_dir` config option** — custom output directory that overrides the default `target/<triple>/<profile>` path for final artifacts. Supported in `build`, `run`, and config validation.
+- **`dcr fmt` command** — new CLI command that formats all C/C++ source files (`*.c`, `*.cpp`, `*.h`, `*.hpp`) in `src/` and `tests/` using `clang-format`.
+- **Incremental linking** — `needs_link()` in `common.rs` checks if any object file is newer than the linked output, skipping unnecessary relinking. Implemented for all backends (`unix_cc`, `msvc`, `gas`, `nasm`).
+- **`build.kind = "none"` and `"custom"`** — two new project kinds for special build scenarios that don't produce standard artifacts.
+- **`install_bsd.sh`** — POSIX-compliant installation script for BSD systems (FreeBSD, OpenBSD, NetBSD) with binary download and source build modes.
+- **Linux ARM64 support in `install.sh`** — added `Linux:aarch64|Linux:arm64` target detection for pre-built binary downloads.
+- **BSD OS detection in `install.sh`** — detects FreeBSD, OpenBSD, NetBSD and determines target triple.
+- **`rust-toolchain.toml`** — explicit toolchain pinning to `stable` channel.
+- **Integration tests** — `build_with_target_config` (verifies `build.target = "linux"`) and `build_with_out_dir` (validates custom output directory).
+- **`get_build_string_with_profile` made `pub`** — so `run.rs` can determine custom output directory configuration.
+
+### Changed
+
+- **`build.target` semantics changed** — now strictly contains a target triple (e.g., `x86_64-unknown-linux-gnu`) or short name (`linux`, `macos`, `windows`). No longer used as custom output directory — this functionality moved to `build.out_dir`.
+- **`build.standard` made optional** — changed from `String` to `Option<String>`. Validation only enforces non-empty for non-ASM languages. Skipped in `dcr.toml` output if empty.
+- **`dcr run` with `out_dir`** — now determines target directory respecting `build.out_dir` via `get_build_string_with_profile()` from `build.rs`.
+- **`collect_sources()` returns empty vector** instead of error when no sources are found, allowing `kind = "none"` or `kind = "custom"` projects with no source files.
+- **CI/CD release workflow refactored** — `git2` made target-specific (no vendored-openssl on Windows), Zig-based cross-compilation for non-x86_64 Linux targets, Arch Linux package version cleanup (dashes → dots), `gmake` symlink for NetBSD.
+- **README compatibility table** — FreeBSD, OpenBSD, NetBSD build/run status upgraded from "community/best-effort" to "officially supported".
+- **Documentation updated** — `build-section.md` describes new `build.target` and `build.out_dir` fields. `target-directory.md` rewritten to clarify the distinction.
+
+### Fixed
+
+- **stdout/stderr not inherited in `dcr run`** — child process output was captured and manually printed, breaking interactive programs. Fixed by switching to `Command::status()`.
+- **Race condition in release CI** — matrix build jobs could upload assets to a release that didn't exist yet. Fixed by adding a dedicated `create-release` job.
+- **Release GHA — stable toolchain override** — fixed Rust toolchain override issues in CI.
+- **Arch Linux package version sanitization** — version strings with dashes (e.g., `0.7.0-dev`) are invalid for `pkgver`. Fixed by replacing dashes with dots.
+- **GPG permissions after Docker** — Docker operations changed GPG directory ownership. Fixed by running `chown` after Docker commands.
+- **RPM artifact paths** — RPM artifacts were placed in `rpm/x86_64/` instead of `fedora/x86_64/`. Fixed in Dexoron Packages Index workflow.
+- **JSON parsing reliability in `install.sh`** — added `jq` as primary parser with `python3` fallback for dev channel release lookup.
+
+### Removed
+
+- **`format_roots()` helper function** — removed from `common.rs`. Was only used by the old error handling path in `collect_sources()`.
+- **Per-distribution artifact download steps** — three separate `actions/download-artifact` steps replaced with unified `gh release download --clobber`.

docs/commands/build-commands.mdx

@@ -0,0 +1,42 @@
+---
+sidebar_label: Build commands (build, run, clean)
+---
+
+# Build Commands
+
+## `dcr build`
+
+Builds the project according to `dcr.toml`.
+
+```bash
+dcr build                         # debug profile
+dcr build --release               # release build
+dcr build --debug                 # explicit debug
+dcr build --target aarch64-unknown-linux-gnu
+dcr build --force                 # full rebuild
+dcr build --clean                 # clean + build
+dcr build --verbose               # show compilation commands
+dcr build --workspace pkg-a       # build specific workspace package
+```
+
+Artifacts: `target/<triple>/<profile>/<binary-name>` (Linux with explicit target).
+
+## `dcr run`
+
+Builds (if sources are newer than artifacts) and runs the binary.
+
+```bash
+dcr run
+dcr run --release
+```
+
+## `dcr clean`
+
+Removes `target/` directory (or `target/<target>/<profile>`).
+
+```bash
+dcr clean
+dcr clean --release               # target/release/ only
+dcr clean --target windows        # target/x86_64-pc-windows-msvc/
+dcr clean --all                   # clean all workspace packages
+```

docs/commands/dcr-build.md

@@ -1,46 +0,0 @@
-# dcr build
-
-Builds the project in `debug` or `release` profile.
-
-## Usage
-
-```sh
-dcr build
-dcr build --debug
-dcr build --release
-```
-
-## What `build` does
-
-1. Checks that `dcr.toml` exists and is valid.
-2. Reads build settings from `[build]`.
-3. Resolves path dependencies from `[dependencies]`.
-4. Creates required output directories.
-5. Recursively compiles sources from `src/`.
-6. Links final artifact (binary or library).
-
-## Config values used
-
-- `package.name`
-- `build.compiler`
-- `build.language`
-- `build.standard`
-- `build.kind`
-- `build.target`
-- `build.platform`
-- `build.cflags`
-- `build.ldflags`
-
-## Source selection
-
-- `language = "c"` -> `*.c`
-- `language = "c++" | "cpp" | "cxx"` -> `*.cpp`, `*.cxx`, `*.cc`
-- `language = "asm"` -> `*.s`, `*.S`, `*.asm`
-
-## Notes
-
-- The profile is selected from the first argument only.
-- Unknown profile flags return an error.
-- Incremental rebuild is based on source/object mtime comparison.
-- For `language = "asm"` with `compiler = "as"`/`"gas"`, use `.s` files (no preprocessing). For `.S`, use `gcc` or `clang`.
-- In workspace root, `dcr build` builds all members in dependency order.

docs/commands/dcr-clean.md

@@ -1,25 +0,0 @@
-# dcr clean
-
-Removes build artifacts in `target/`.
-
-## Usage
-
-```sh
-dcr clean
-dcr clean --debug
-dcr clean --release
-dcr clean --all
-dcr clean --release --all
-```
-
-## Behavior
-
-- Without arguments: removes entire `target/`.
-- With profile: removes only `target/<profile>/`.
-- With `--all`: also cleans all workspace members.
-
-## Validation
-
-- `dcr.toml` must exist.
-- Unknown flags are treated as error.
-- If `target` or selected profile directory does not exist, command prints a warning.

docs/commands/dcr-init-or-new.md

@@ -1,43 +0,0 @@
-# dcr init/new
-
-## `dcr new <name>`
-
-Creates a new project directory and initializes it.
-
-```sh
-dcr new hello
-```
-
-Behavior:
-
-1. Validates arguments (`<name>` is required, only one name is allowed).
-2. Creates `<name>/`.
-3. Creates `<name>/dcr.toml`.
-4. Sets `package.name = "<name>"`.
-5. Creates `<name>/src/main.c` with a Hello World template.
-
-Errors:
-
-- Missing project name.
-- Extra arguments.
-- Target directory already exists.
-
-## `dcr init`
-
-Initializes DCR in the current directory.
-
-```sh
-dcr init
-```
-
-Behavior:
-
-1. Requires current directory to be empty.
-2. Creates `dcr.toml`.
-3. Sets `package.name` from the current directory name.
-4. Creates `src/main.c`.
-
-Errors:
-
-- Any arguments are treated as invalid.
-- Non-empty directory is rejected.

docs/commands/dcr-run.md

@@ -1,27 +0,0 @@
-# dcr run
-
-Builds the project and runs the resulting binary.
-
-## Usage
-
-```sh
-dcr run
-dcr run --debug
-dcr run --release
-```
-
-## Behavior
-
-1. Validates `dcr.toml`.
-2. Reads `package.name`, `build.kind`, and optional `build.target`.
-3. Runs the same build flow as `dcr build`.
-4. Executes the built artifact path for the selected profile.
-
-## Restrictions
-
-- If `build.kind = "staticlib"` or `build.kind = "sharedlib"`, `run` exits with error.
-- The profile is selected from the first argument.
-
-## On build failure
-
-`dcr run` attempts to launch an existing binary from the same profile if present; otherwise it reports that code errors must be fixed.

docs/commands/dependency-commands.mdx

@@ -0,0 +1,51 @@
+---
+sidebar_label: Dependency commands (add, tree)
+---
+
+# Dependency Commands
+
+## `dcr add <name> [source]`
+
+Adds a dependency to `dcr.toml`.
+
+```bash
+dcr add fmt                    # registry lookup
+dcr add mylib ../path/to/lib   # path as source
+dcr add mylib path:./lib       # explicit path prefix
+dcr add mylib git:https://github.com/user/repo  # explicit git prefix
+dcr add mylib github:user/repo # GitHub shorthand
+dcr add mylib gitlab:user/repo # GitLab shorthand
+```
+
+Source prefixes:
+- `path:` — local path
+- `git:` — generic git URL
+- `github:` — expands to `https://github.com/<user>/<repo>`
+- `gitlab:` — expands to `https://gitlab.com/<user>/<repo>`
+- `http://` / `https://` / `git@` — full URL
+
+Flags:
+- `--branch <name>` — git branch
+- `--tag <name>` — git tag
+- `--rev <hash>` — git commit
+
+If source is omitted — DCR searches connected registries.
+
+## `dcr tree`
+
+Displays the project dependency tree.
+
+```bash
+dcr tree
+```
+
+Example output:
+
+```
+my-app v0.1.0
+├── fmt (registry)
+│   └── spdlog (registry)
+└── catch2 (registry)
+```
+
+For path dependencies, recursively shows their own dependencies (from their `dcr.toml`).

docs/commands/gen-commands.mdx

@@ -0,0 +1,71 @@
+---
+sidebar_label: Gen commands (vscode, clion, ...)
+---
+
+# Gen Commands
+
+## `dcr gen <target>`
+
+Generates IDE integration files.
+
+### vscode
+
+```bash
+dcr gen vscode
+```
+
+Creates:
+- `.vscode/tasks.json` — `build` task (dcr build)
+- `.vscode/launch.json` — debug launch configuration
+- `.vscode/settings.json` — C/C++ settings (clangd paths, includes)
+- `.vscode/extensions.json` — recommended extensions (vscode-clangd, vscode-lldb)
+
+### clion
+
+```bash
+dcr gen clion
+```
+
+Creates:
+- `.idea/externalTools.xml` — external tools (build, run, clean, test)
+- `.idea/customTargets.xml` — custom build targets
+- `.idea/misc.xml` — C/C++ project settings
+- `.idea/runConfigurations/<name>.xml` — per-binary run configurations
+
+### compile-commands
+
+```bash
+dcr gen compile-commands
+```
+
+Generates `compile_commands.json` — standard format for clangd, cpptools, static analyzers.
+
+### project-info
+
+```bash
+dcr gen project-info
+```
+
+Outputs JSON array with project metadata:
+
+```json
+[
+  {
+    "name": "my-app",
+    "version": "0.1.0",
+    "root": "/path/to/project",
+    "profile": "debug",
+    "language": "c",
+    "standard": "c17",
+    "cxx_standard": null,
+    "compiler": "/usr/bin/clang",
+    "kind": "bin",
+    "sources": ["src/main.c"],
+    "include_dirs": ["src"],
+    "lib_dirs": [],
+    "libs": [],
+    "cflags": ["-std=c17", "-O0", "-g"],
+    "ldflags": []
+  }
+]
+```

docs/commands/global-options.md

@@ -1,44 +0,0 @@
-# Global options
-
-## `dcr --help`
-
-```sh
-dcr --help
-```
-
-Prints top-level CLI usage, commands, flags, and examples.
-
-## `dcr --version`
-
-```sh
-dcr --version
-```
-
-Prints:
-
-```text
-dcr <version> (<target>)
-```
-
-## `dcr --update`
-
-```sh
-dcr --update
-```
-
-Update flow:
-
-1. Requests latest release from GitHub API.
-2. Finds asset matching current `DCR_TARGET`.
-3. Downloads replacement binary.
-4. Replaces current executable via `self-replace`.
-
-Limitations and behavior:
-
-- No extra arguments are accepted.
-- Requires network access to GitHub API/assets.
-- On Linux, if binary is owned by pacman, DCR prints package-manager update instructions instead of self-updating.
-
-## Running without command
-
-Running plain `dcr` (without arguments) shows help output.

docs/commands/project-commands.mdx

@@ -0,0 +1,28 @@
+---
+sidebar_label: Project commands (new, init)
+---
+
+# Project Commands
+
+## `dcr new <name>`
+
+Creates a new project with a standard structure and `dcr.toml`. The `name` argument is required.
+
+```bash
+dcr new my-app
+```
+
+Generates:
+- `dcr.toml` with basic fields
+- `src/main.c` with a `main` template
+
+## `dcr init`
+
+Initializes a DCR project in the current (empty) directory.
+
+```bash
+mkdir app && cd app
+dcr init
+```
+
+The project name is taken from the current directory name.

docs/commands/quality-commands.mdx

@@ -0,0 +1,44 @@
+---
+sidebar_label: Quality commands (test, fmt)
+---
+
+# Quality Commands
+
+## `dcr test`
+
+Runs tests.
+
+```bash
+dcr test                          # debug profile
+dcr test --release                # release profile
+dcr test --debug                  # explicit debug
+dcr test --help                   # detailed help
+```
+
+Before first use, initialize tests:
+
+```bash
+dcr test --init
+```
+
+This creates `tests/dcr_test.h` (framework) and `tests/test.c` (template).
+
+What `dcr test` does:
+1. Builds the project
+2. Collects `tests/*.c` files (`.c` only, not `.cpp`)
+3. Compiles and links each test file
+4. Runs each test binary
+5. Prints summary: TOTAL, PASS, SKIP, FAIL
+6. Returns non-zero exit code on any FAIL
+
+## `dcr fmt`
+
+Formats C/C++ source files using `clang-format`.
+
+```bash
+dcr fmt
+```
+
+Processes: `src/**/*.{c,cpp,cxx,cc,h,hpp,hxx,hh}` and `tests/**/*.{c,cpp,cxx,cc,h,hpp,hxx,hh}`.
+
+Uses `.clang-format` at the project root (if present), otherwise default clang-format style.

docs/commands/system-commands.mdx

@@ -0,0 +1,50 @@
+---
+sidebar_label: System commands (setup, --help, ...)
+---
+
+# System Commands
+
+## `dcr setup`
+
+Shows configured registries from `~/.dcr/config.toml`.
+
+```bash
+dcr setup
+```
+
+If `~/.dcr/config.toml` is not found, DCR returns an error. Create it manually:
+
+```toml
+[[registry]]
+name = "default"
+url = "https://index.dcr.pm"
+```
+
+## `dcr --help`
+
+Shows help for all commands.
+
+```bash
+dcr --help
+```
+
+## `dcr --version`
+
+Shows version and target triple.
+
+```bash
+dcr --version       # dcr 0.7.0 (x86_64-unknown-linux-gnu)
+```
+
+## `dcr --update`
+
+Self-update. Downloads the latest release binary from GitHub Releases and replaces the current one.
+
+```bash
+dcr --update
+```
+
+Features:
+- Auto-detects platform and architecture
+- Warns if installed via AUR (use package manager instead)
+- Works on Linux, macOS, Windows

docs/configuration/build-profiles.md

@@ -1,57 +0,0 @@
-# Build profiles
-
-DCR supports two profiles:
-
-- `debug` (default)
-- `release`
-
-## How to select
-
-```sh
-dcr build --debug
-dcr build --release
-dcr run --release
-dcr clean --debug
-```
-
-## Default profile flags
-
-### GCC/Clang-like toolchains
-
-- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDEBUG`
-- `release`: `-O3 -DNDEBUG -march=native`
-
-### MSVC toolchain
-
-- `debug`: `/Od /Zi /W4 /DDEBUG /Oy-`
-- `release`: `/O2 /DNDEBUG`
-
-## Artifacts
-
-By default:
-
-- `target/debug/<name>` (or `.exe` on Windows)
-- `target/release/<name>` (or `.exe` on Windows)
-
-Default compiler flags:
-
-GCC/Clang:
-
-- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDEBUG`
-- `release`: `-O3 -DNDEBUG -march=native`
-
-MSVC:
-
-- `debug`: `/Od /Zi /W4 /DDEBUG /Oy-`
-- `release`: `/O2 /DNDEBUG`
-
-Static library mode (`kind = "staticlib"`):
-
-- Linux/macOS: `lib<name>.a`
-- Windows: `<name>.lib`
-
-Shared library mode (`kind = "sharedlib"`):
-
-- Linux: `lib<name>.so`
-- macOS: `lib<name>.dylib`
-- Windows: `<name>.dll`

docs/configuration/build-section.md

@@ -1,44 +0,0 @@
-# Build section
-
-## Schema
-
-```toml
-[build]
-language = "c"
-standard = "c11"
-compiler = "clang"
-kind = "bin"
-# optional:
-# target = "./dist"
-# platform = "x86_64"
-# cflags = ["-Wall"]
-# ldflags = ["-lm"]
-```
-
-## Fields
-
-- `language` (string, required): `c`, `c++`, `cpp`, `cxx`, or `asm`.
-- `standard` (string, required): language standard passed to compiler.
-- `compiler` (string, required): compiler command (for example `clang`, `gcc`, `cl`).
-- `kind` (string, required): `bin`, `staticlib`, or `sharedlib`.
-- `target` (string, optional): custom output directory for final artifact.
-- `platform` (string, optional): architecture hint for compiler (used for `-march` or `/arch`).
-- `cflags` (string array, optional): extra compile flags.
-- `ldflags` (string array, optional): extra link flags.
-
-## Toolchain section
-
-```toml
-[toolchain]
-cc = "clang"
-cxx = "clang++"
-as = "as"
-ar = "ar"
-ld = "ld"
-```
-
-## Behavior notes
-
-- Compiler backend is selected by compiler string (`gcc`, `clang`, `cl`, `clang-cl`).
-- Empty or unknown compiler value falls back to clang-like build path.
-- `run` is not allowed for library kinds (`staticlib`, `sharedlib`).

docs/configuration/dcr.toml-overview.md

@@ -1,50 +0,0 @@
-# dcr.toml overview
-
-`dcr.toml` is the main project file used by DCR.
-
-## Minimal generated template
-
-```toml
-[package]
-name = "hello"
-version = "0.1.0"
-
-[build]
-language = "c"
-standard = "c11"
-compiler = "clang"
-kind = "bin"
-
-[dependencies]
-```
-
-`dcr new` and `dcr init` generate this structure automatically.
-
-## Required sections
-
-- `[package]`
-- `[build]`
-- `[dependencies]`
-
-Workspace-only root:
-- `[workspace]` may be used instead of `[package]`/`[build]` for a workspace root.
-
-## Required keys
-
-- `package.name`
-- `package.version`
-- `build.language`
-- `build.standard`
-- `build.compiler`
-- `build.kind`
-
-`build.kind` must be either `bin`, `staticlib`, or `sharedlib`.
-
-## Optional keys
-
-- `build.target`
-- `build.cflags`
-- `build.ldflags`
-- dependency fields (`include`, `lib`, `libs`, `system`)
-- `[toolchain]` overrides (`cc`, `cxx`, `as`, `ar`, `ld`)
-- `[workspace]` members

docs/configuration/dependencies-section.md

@@ -1,30 +0,0 @@
-# Dependencies section
-
-DCR currently supports path dependencies.
-
-## Example
-
-```toml
-[dependencies]
-frecli = { path = "./lib/frecli", include = ["."], lib = ["."], libs = ["frecli"] }
-```
-
-## Supported fields per dependency
-
-- `path` (string, required): absolute path or path relative to project root.
-- `include` (string array, optional): include directories inside dependency.
-- `lib` (string array, optional): library directories inside dependency.
-- `libs` (string array, optional): library names for linker.
-- `system` (bool, optional): currently `system = true` is rejected.
-
-## Defaults
-
-- If `include` is omitted, DCR tries `<dep>/include`.
-- If `lib` is omitted, DCR tries `<dep>/lib`, then `<dep>/lib64`.
-- If `libs` is omitted, dependency key name is used.
-
-## Validation
-
-- Dependency value must be a TOML table.
-- `path` is mandatory.
-- `include`/`lib`/`libs` must be arrays of strings if provided.

docs/configuration/package-section.md

@@ -1,20 +0,0 @@
-# Package section
-
-## Schema
-
-```toml
-[package]
-name = "my-app"
-version = "0.1.0"
-```
-
-## Fields
-
-- `name` (string, required): used as output artifact base name.
-- `version` (string, required): used in `dcr.lock` project entry.
-
-## Notes
-
-- Empty `name` or `version` makes config invalid.
-- `dcr new` sets `name` from the passed project name.
-- `dcr init` sets `name` from current directory name.

docs/contributing.mdx

@@ -0,0 +1,50 @@
+---
+sidebar_label: Contributing
+---
+
+# Contributing
+
+## Setup
+
+```bash
+git clone https://github.com/dexoron/dcr
+cd dcr
+cargo build
+```
+
+## Code style
+
+All code must be formatted with `cargo fmt`:
+
+```bash
+cargo fmt
+```
+
+## Linting
+
+```bash
+cargo clippy --all-targets -- -D warnings
+```
+
+## Tests
+
+```bash
+cargo test --all-targets
+```
+
+## PR process
+
+1. Fork the repository
+2. Create a branch: `git checkout -b feature/description`
+3. Make changes
+4. Run `cargo fmt && cargo clippy && cargo test`
+5. Open a Pull Request
+
+## CI
+
+CI runs:
+- `cargo fmt --check`
+- `cargo clippy --all-targets -- -D warnings`
+- `cargo test --all-targets`
+- Build on Linux, macOS, Windows
+- Integration tests

docs/dependencies-and-build/compilers-and-linking.md

@@ -1,71 +0,0 @@
-# Compilers & linking
-
-## Compiler backend selection
-
-DCR picks a backend from `build.compiler`:
-
-- contains `clang-cl` -> MSVC backend
-- equals `as` or contains `gas` -> GAS backend (standalone assembler)
-- contains `gcc` or `g++` -> GCC backend
-- contains `clang` or `clang++` -> Clang backend
-- equals `cl` or contains `msvc` -> MSVC backend
-- contains `nasm` -> NASM backend
-- otherwise -> Clang backend fallback
-
-## Compilation model
-
-- Source files are found recursively in `src/` based on `build.language`.
-- Each source is compiled to `target/<profile>/obj/<relative-path>.o` (`.obj` on MSVC).
-- Recompile happens when source mtime is newer than object mtime.
-
-## Default build flags
-
-These flags are applied automatically based on profile and compiler backend.
-
-GCC/Clang:
-
-- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDEBUG`
-- `release`: `-O3 -DNDEBUG -march=native`
-
-MSVC:
-
-- `debug`: `/Od /Zi /W4 /DDEBUG /Oy-`
-- `release`: `/O2 /DNDEBUG`
-
-## Platform hint
-
-If `build.platform` is set, DCR passes it as an architecture hint:
-
-- GCC/Clang: `-march=<platform>`
-- MSVC: maps to `/arch:*` for known values (`x86`, `i386`, `i486`, `i586`, `i686`, `sse2`, `avx`, `avx2`)
-
-## Toolchain overrides
-
-If `[toolchain]` is set, DCR uses its values to override compiler/linker tools:
-
-- `cc`, `cxx`, `as` override compilers for C/C++/ASM
-- `ar` overrides the archiver (used for `staticlib`)
-- `ld` overrides the linker (used by GCC/Clang/NASM/GAS backends)
-
-Environment overrides (highest priority):
-- `DCR_COMPILER` (all languages)
-- `DCR_CC`, `DCR_CXX`, `DCR_AS`, `DCR_AR`, `DCR_LD`
-
-## Linking
-
-For `kind = "bin"`:
-
-- Object files are linked into executable artifact.
-- Dependency lib dirs and library names are passed to linker.
-- `build.ldflags` are appended to link command.
-
-For `kind = "staticlib"`:
-
-- Linux/macOS (GCC/Clang): `ar rcs` creates `.a` archive.
-- Windows (MSVC): `lib` creates `.lib` archive.
-
-For `kind = "sharedlib"`:
-
-- Linux (GCC/Clang): `-shared` with output `.so`.
-- macOS (Clang): `-dynamiclib` with output `.dylib`.
-- Windows (MSVC): `/LD` with output `.dll`.

docs/dependencies-and-build/dependency-format.md

@@ -1,26 +0,0 @@
-# Dependency format
-
-Dependencies are defined in `dcr.toml` under `[dependencies]`.
-
-## Full example
-
-```toml
-[dependencies]
-fmt = { path = "./third_party/fmt", include = ["include"], lib = ["lib"], libs = ["fmt"] }
-```
-
-## Field reference
-
-- `path`: required dependency root path.
-- `include`: optional include subpaths (absolute or relative to dep root).
-- `lib`: optional library subpaths (absolute or relative to dep root).
-- `libs`: optional linker library names.
-
-## Common valid compact form
-
-```toml
-[dependencies]
-mylib = { path = "./libs/mylib" }
-```
-
-In this form DCR will try defaults for include/lib dirs and use `mylib` as the linker library name.

docs/dependencies-and-build/local-dependencies.md

@@ -1,19 +0,0 @@
-# Local dependencies
-
-## Resolution flow during build
-
-For each dependency in `[dependencies]`, DCR:
-
-1. Resolves `path` (absolute or project-relative).
-2. Resolves include dirs (`include` or default `include`).
-3. Resolves lib dirs (`lib` or defaults `lib`, `lib64`).
-4. Resolves link libs (`libs` or dependency name).
-5. Synchronizes dependency files to `target/<profile>/deps/<dep-name>/`.
-6. Adds include/lib/link options to compile/link commands.
-
-## Failure cases
-
-- Dependency path is missing or not a directory.
-- No valid include/lib directories were found.
-- Any configured include/lib path does not exist.
-- Invalid field types in dependency config.

docs/dependencies-and-build/target-directory.md

@@ -1,23 +0,0 @@
-# Target directory
-
-By default, DCR writes final artifacts to `target/<profile>/`.
-
-You can override this with `build.target`:
-
-```toml
-[build]
-target = "./dist"
-```
-
-## Behavior
-
-- Binary mode:
-  - Linux/macOS: `<target>/<name>`
-  - Windows: `<target>/<name>.exe`
-- Static library mode:
-  - Linux/macOS: `<target>/lib<name>.a`
-  - Windows: `<target>/<name>.lib`
-
-## Important detail
-
-`build.target` changes only the final artifact location. Object cache and dependency sync directories still use `target/<profile>/...`.

docs/dependencies-and-build/versioning-and-lock-file.md

@@ -1,32 +0,0 @@
-# Versioning & lock file
-
-DCR generates `dcr.lock` when dependency resolution succeeds and at least one dependency exists.
-
-## What is stored
-
-- Project entry (`name`, `version`, dependency names).
-- One entry per resolved dependency:
-  - `name`
-  - `version` (from dependency `dcr.toml`, fallback `0.0.0`)
-  - `source` (`path+...`)
-  - `checksum` (SHA-256 over dependency files, excluding nested `target/`).
-
-## Example shape
-
-```toml
-[[package]]
-name = "my-app"
-version = "0.1.0"
-dependencies = ["fmt"]
-
-[[package]]
-name = "fmt"
-version = "1.2.3"
-source = "path+./third_party/fmt"
-checksum = "..."
-```
-
-## Notes
-
-- `dcr.lock` is rewritten on successful dependency resolution.
-- If `[dependencies]` is empty, lock generation is skipped.

docs/faq.mdx

@@ -0,0 +1,81 @@
+---
+sidebar_label: FAQ
+---
+
+# FAQ
+
+## Registry not found
+
+```
+error: registry not found
+```
+
+**Solution:** Make sure `~/.dcr/config.toml` exists:
+
+```toml
+[[registry]]
+name = "default"
+url = "https://index.dcr.pm"
+```
+
+And check `DCR_INDEX_PATH`:
+
+```bash
+echo $DCR_INDEX_PATH
+```
+
+## Compiler not found
+
+```
+error: compiler not found
+```
+
+**Solution:** Ensure a compiler is installed and available in PATH.
+
+```bash
+which gcc
+which clang
+```
+
+Or specify explicitly via `[toolchain]` in `dcr.toml`.
+
+## openssl-sys build failed
+
+When building DCR from source:
+
+```
+error: failed to run custom build command for openssl-sys
+```
+
+**Solution:** Install OpenSSL development headers:
+
+```bash
+# Ubuntu/Debian
+sudo apt install libssl-dev
+
+# Fedora
+sudo dnf install openssl-devel
+
+# macOS
+brew install openssl
+```
+
+## Ctrl+C during build
+
+DCR handles SIGINT: interrupts the current compilation and exits with non-zero code.
+
+## How to create a library?
+
+See [Library Recipe](/docs/recipes/library-project).
+
+## How to cross-compile to Windows?
+
+See [Cross-Compile Recipe](/docs/recipes/cross-to-windows).
+
+## How to create a multi-package project?
+
+See [Workspace Recipe](/docs/recipes/multi-package-workspace).
+
+## Lock file
+
+`dcr.lock` is created during builds (`dcr build`) when registry dependencies are present. To force an update — delete `dcr.lock` and run `dcr build`.

docs/getting-started/build-and-run.md

@@ -1,49 +0,0 @@
-# Build and run
-
-## Build
-
-Debug (default):
-
-```sh
-dcr build
-# or
-dcr build --debug
-```
-
-Release:
-
-```sh
-dcr build --release
-```
-
-## Run
-
-```sh
-dcr run
-# or
-dcr run --release
-```
-
-`dcr run` first builds, then launches the produced binary.
-
-## Clean artifacts
-
-```sh
-dcr clean
-```
-
-Profile-only cleanup:
-
-```sh
-dcr clean --debug
-dcr clean --release
-dcr clean --all
-dcr clean --release --all
-```
-
-## Notes
-
-- `run` is unavailable for `build.kind = "staticlib"` and `build.kind = "sharedlib"`.
-- Build profile flag is parsed from the first command argument.
-- Unknown profile flags produce an error.
-- In workspace root, `clean --all` cleans all member projects.

docs/getting-started/create-your-first-project.md

@@ -1,41 +0,0 @@
-# Create your first project
-
-## Create in a new folder
-
-```sh
-dcr new hello
-cd hello
-```
-
-This creates:
-
-```text
-hello/
-- dcr.toml
-- src/
-- - main.c
-```
-
-## Or initialize current folder
-
-```sh
-mkdir hello
-cd hello
-dcr init
-```
-
-`dcr init` requires the current directory to be empty.
-
-## Next steps
-
-Build and run:
-
-```sh
-dcr run
-```
-
-Release build/run:
-
-```sh
-dcr run --release
-```

docs/getting-started/first-steps.mdx

@@ -0,0 +1,70 @@
+---
+sidebar_label: First steps
+---
+
+# First Steps
+
+## Create a project
+
+```bash
+dcr new my-app
+cd my-app
+```
+
+Structure:
+
+```
+my-app/
+├── dcr.toml
+└── src/
+    └── main.c
+```
+
+`dcr.toml`:
+```toml
+[package]
+name = "my-app"
+version = "0.1.0"
+type = "none"
+
+[build]
+language = "c"
+standard = "c11"
+compiler = "clang"
+kind = "bin"
+```
+
+## Build
+
+```bash
+dcr build
+```
+
+Output — `target/<triple>/debug/my-app` (Linux) or `target/debug/my-app.exe` (Windows).
+
+Build profiles:
+```bash
+dcr build --release       # release build
+dcr build --debug         # debug (default)
+```
+
+## Run
+
+```bash
+dcr run
+```
+
+Builds (if needed) and runs the binary.
+
+## First test
+
+```bash
+dcr test --init      # create test template
+dcr test             # run tests
+```
+
+## Formatting
+
+```bash
+dcr fmt              # clang-format with .clang-format
+```

docs/getting-started/installation.md

@@ -1,56 +0,0 @@
-# Installation
-
-## Option 1: Install via script
-
-### Linux/macOS
-
-```sh
-curl -fsSL https://dcr.dexoron.su/install.sh | bash
-```
-
-Alternative with `wget`:
-
-```sh
-wget -qO- https://dcr.dexoron.su/install.sh | bash
-```
-
-### Windows (PowerShell)
-
-```powershell
-powershell -ExecutionPolicy ByPass -c "irm https://dcr.dexoron.su/install.ps1 | iex"
-```
-
-## Option 2: Build from source
-
-```sh
-git clone https://github.com/dexoron/dcr.git
-cd dcr
-cargo build --release
-mkdir -p ~/.local/bin
-ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
-```
-
-## Option 3: Arch Linux (AUR)
-
-```sh
-yay -S dcr
-```
-
-(You can also use `paru` or other AUR helpers.)
-
-## Verify installation
-
-```sh
-dcr --version
-```
-
-Expected format:
-
-```text
-dcr <version> (<target>)
-```
-
-## Update policy
-
-- If DCR was installed from GitHub releases, scripts, or manual build: use `dcr --update`.
-- If DCR is managed by `pacman/AUR`: update via package manager. On Linux, `dcr --update` detects pacman-owned binaries and prints a package-manager hint.

docs/getting-started/installation.mdx

@@ -0,0 +1,93 @@
+---
+sidebar_label: Installation
+---
+
+# Installation
+
+## Linux (Dexoron Packages)
+
+Configure your package manager at https://dcr.dexoron.su and install:
+
+**Arch Linux**
+```sh
+sudo pacman -Sy dcr
+```
+
+**Debian/Ubuntu**
+```sh
+sudo apt update && sudo apt install dcr
+```
+
+**Fedora/RHEL**
+```sh
+sudo dnf install dcr
+```
+
+## Arch Linux (AUR)
+
+```sh
+yay -S dcr
+```
+
+## macOS / Linux (Homebrew)
+
+```sh
+brew tap dexoron/dexoron
+brew install dcr
+```
+
+## Nix (flake)
+
+```sh
+nix run github:dexoron/dcr
+# or install to profile:
+nix profile install github:dexoron/dcr
+```
+
+## Cargo (crates.io)
+
+```sh
+cargo install dcr
+```
+
+## Linux / macOS (script)
+
+```sh
+curl -fsSL https://dcr.dexoron.su/install.sh | bash
+```
+
+## BSD (script)
+
+```sh
+curl -fsSL https://dcr.dexoron.su/install_bsd.sh | bash
+```
+
+## Windows (PowerShell)
+
+```powershell
+irm https://dcr.dexoron.su/install.ps1 | iex
+```
+
+## From source
+
+```sh
+git clone https://github.com/dexoron/dcr.git
+cd dcr && cargo build --release
+ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+```
+
+## Post-install
+
+Verify the installation:
+
+```bash
+dcr --version
+```
+
+To use the registry, create `~/.dcr/config.toml`:
+
+```toml
+[[registry]]
+name = "default"
+url = "https://index.dcr.pm"
+```

docs/getting-started/project-structure.md

@@ -1,40 +0,0 @@
-# Project structure
-
-## Minimal project
-
-```text
-project/
-- dcr.toml
-- src/
-- - main.c
-```
-
-## Typical generated/optional files
-
-```text
-project/
-- dcr.toml
-- dcr.lock
-- src/
-- - ... source files ...
-- target/
-- - debug/
-- - - obj/
-- - - deps/
-- - release/
-- - - obj/
-- - - deps/
-```
-
-## Meaning
-
-- `dcr.toml`: main project configuration.
-- `dcr.lock`: generated lock file for resolved path dependencies.
-- `src/`: recursively scanned source directory.
-- `target/<profile>/obj/`: cached object files for incremental rebuild.
-- `target/<profile>/deps/`: synchronized copies of path dependencies.
-- `target/<profile>/<name>` (or `.exe` on Windows): output for `kind = "bin"`.
-- `target/<profile>/lib<name>.a` (or `<name>.lib` on Windows): output for `kind = "staticlib"`.
-- `target/<profile>/lib<name>.so` (or `.dylib` on macOS, `<name>.dll` on Windows): output for `kind = "sharedlib"`.
-
-If `build.target` is set, the final artifact is written to that custom directory, while object cache still stays in `target/<profile>/obj`.

docs/ide-integration.mdx

@@ -0,0 +1,51 @@
+---
+sidebar_label: IDE Integration
+---
+
+# IDE Integration
+
+## VS Code
+
+```bash
+dcr gen vscode
+```
+
+Generates in `.vscode/`:
+
+| File | Purpose |
+|------|---------|
+| `tasks.json` | `build` task (dcr build) |
+| `launch.json` | Debug launch configuration |
+| `settings.json` | clangd/IntelliSense: include paths, standard |
+| `extensions.json` | Recommends vscode-clangd, vscode-lldb |
+
+## CLion
+
+```bash
+dcr gen clion
+```
+
+Generates in `.idea/`:
+
+| File | Purpose |
+|------|---------|
+| `externalTools.xml` | Build, Run, Clean, Test as external tools |
+| `customTargets.xml` | Custom build targets |
+| `misc.xml` | C/C++ project settings |
+| `runConfigurations/<name>.xml` | Per-binary run configurations |
+
+## compile_commands.json
+
+```bash
+dcr gen compile-commands
+```
+
+Generates `compile_commands.json` at project root. Standard format for clangd, C/C++ IntelliSense, static analyzers.
+
+## project-info
+
+```bash
+dcr gen project-info
+```
+
+Outputs JSON array with project metadata (see [gen-commands](/docs/commands/gen-commands)).

docs/recipes/cross-to-windows.mdx

@@ -0,0 +1,49 @@
+---
+sidebar_label: Cross-compile to Windows
+---
+
+# Cross-Compile to Windows from Linux
+
+Building a Windows binary on Linux using mingw-w64.
+
+## Install toolchain
+
+```bash
+# Ubuntu/Debian
+sudo apt install mingw-w64
+
+# Fedora
+sudo dnf install mingw64-gcc mingw64-binutils
+```
+
+## Configuration
+
+```toml
+[package]
+name = "my-app"
+version = "0.1.0"
+type = "none"
+
+[build]
+language = "c"
+standard = "c11"
+compiler = "clang"
+kind = "bin"
+target = "x86_64-pc-windows-gnu"    # explicit mingw, not msvc
+```
+
+## Build
+
+```bash
+dcr build --target x86_64-pc-windows-gnu --release
+```
+
+Artifact: `target/x86_64-pc-windows-gnu/release/my-app.exe`.
+
+## Custom toolchain
+
+```toml
+[toolchain]
+cc = "x86_64-w64-mingw32-gcc"
+cxx = "x86_64-w64-mingw32-g++"
+```

docs/recipes/library-project.mdx

@@ -0,0 +1,65 @@
+---
+sidebar_label: Library project
+---
+
+# Library Project
+
+Creating a static library and using it in another project.
+
+## Step 1: Create the library
+
+```bash
+dcr new my-lib
+cd my-lib
+```
+
+`dcr.toml`:
+```toml
+[package]
+name = "my-lib"
+version = "0.1.0"
+type = "none"
+
+[build]
+language = "c"
+standard = "c11"
+kind = "staticlib"
+```
+
+`src/my_lib.h`:
+```c
+#ifndef MY_LIB_H
+#define MY_LIB_H
+int add(int a, int b);
+#endif
+```
+
+`src/my_lib.c`:
+```c
+#include "my_lib.h"
+int add(int a, int b) { return a + b; }
+```
+
+## Step 2: Build
+
+```bash
+dcr build --release
+```
+
+Artifacts:
+- `target/<triple>/release/libmy-lib.a` (Linux)
+- `target/release/my-lib.lib` (Windows)
+- `target/include/` — header files
+
+## Step 3: Use in another project
+
+```bash
+dcr new my-app
+cd my-app
+dcr add my-lib ../my-lib
+```
+
+Automatically:
+- Adds include path to `target/include/` of the library
+- Adds lib path to `target/<triple>/release/`
+- Links `libmy-lib.a` / `my-lib.lib`

docs/recipes/multi-package-workspace.mdx

@@ -0,0 +1,98 @@
+---
+sidebar_label: Multi-package workspace
+---
+
+# Multi-Package Workspace
+
+A project with three packages: two libraries and a binary.
+
+## Structure
+
+```
+workspace/
+├── dcr.toml              # root workspace
+├── lib-core/
+│   ├── dcr.toml
+│   └── src/core.c
+├── lib-utils/
+│   ├── dcr.toml
+│   └── src/utils.c
+└── app/
+    ├── dcr.toml
+    └── src/main.c
+```
+
+## Root dcr.toml
+
+```toml
+[package]
+name = "my-workspace"
+version = "0.1.0"
+type = "none"
+
+[build]
+inherit = true
+language = "c"
+standard = "c11"
+
+[workspace.lib-core]
+path = "lib-core"
+
+[workspace.lib-utils]
+path = "lib-utils"
+deps = ["lib-core"]
+
+[workspace.app]
+path = "app"
+deps = ["lib-core", "lib-utils"]
+main = true
+```
+
+## Packages
+
+`lib-core/dcr.toml`:
+```toml
+[package]
+name = "lib-core"
+version = "0.1.0"
+type = "none"
+
+[build]
+kind = "staticlib"
+```
+
+`lib-utils/dcr.toml`:
+```toml
+[package]
+name = "lib-utils"
+version = "0.1.0"
+type = "none"
+
+[build]
+kind = "staticlib"
+```
+
+`app/dcr.toml`:
+```toml
+[package]
+name = "app"
+version = "0.1.0"
+type = "none"
+
+[build]
+kind = "bin"
+```
+
+## Build
+
+```bash
+cd workspace
+dcr build                     # builds everything in correct order
+dcr build --workspace app     # only app (lib-core and lib-utils built as deps)
+dcr run                       # builds and runs main package
+```
+
+Build order (topological sort):
+1. `lib-core`
+2. `lib-utils` (depends on lib-core)
+3. `app` (depends on lib-core, lib-utils)

docs/reference-and-help/cli-reference.md

@@ -1,26 +0,0 @@
-# CLI reference
-
-## Command list
-
-```text
-dcr new <name>
-dcr init
-dcr build [--debug|--release]
-dcr run [--debug|--release]
-dcr clean [--debug|--release] [--all]
-dcr --help
-dcr --version
-dcr --update
-```
-
-## Notes on argument parsing
-
-- Most commands parse profile from the first argument.
-- `new` requires exactly one argument.
-- `init` and `--update` do not accept extra arguments.
-- `clean` accepts `--debug|--release` and optional `--all`.
-
-## Exit behavior overview
-
-- Successful command execution returns `0`.
-- Validation/build/runtime errors return non-zero status.

docs/reference-and-help/config-reference.md

@@ -1,52 +0,0 @@
-# Config reference
-
-## Full schema
-
-```toml
-[package]
-name = "string"      # required
-version = "string"   # required
-
-[build]
-language = "c|c++|cpp|cxx|asm"     # required
-standard = "string"            # required
-compiler = "string"            # required
-kind = "bin|staticlib|sharedlib"         # required
-target = "string"              # optional
-platform = "string"            # optional
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
-
-[toolchain]
-cc = "string"   # optional
-cxx = "string"  # optional
-as = "string"   # optional
-ar = "string"   # optional
-ld = "string"   # optional
-
-[workspace]
-name = { path = "string", deps = ["string", "..."] }
-
-[dependencies]
-name = {
-  path = "string",              # required for each dependency
-  include = ["string", "..."],  # optional
-  lib = ["string", "..."],      # optional
-  libs = ["string", "..."],     # optional
-}
-```
-
-## Validation rules
-
-- `[package]`, `[build]`, `[dependencies]` must exist.
-- Required string fields must be non-empty.
-- `build.kind` must be `bin`, `staticlib`, or `sharedlib`.
-- Dependency fields `include/lib/libs` must be string arrays when provided.
-
-## Generated defaults (`dcr new` / `dcr init`)
-
-- `package.version = "0.1.0"`
-- `build.language = "c"`
-- `build.standard = "c11"`
-- `build.compiler = "clang"`
-- `build.kind = "bin"`

docs/reference-and-help/contributing-and-bug-reports.md

@@ -1,34 +0,0 @@
-# Contributing & Bug reports
-
-## Contribution workflow
-
-1. Fork `dexoron/dcr` (and `dexoron/dcr-site` if docs website changes are needed).
-2. Make focused changes.
-3. Run checks locally:
-
-```bash
-cargo fmt --all
-cargo clippy --all-targets --all-features -- -D warnings
-cargo check
-```
-
-4. Open a PR with short rationale and behavior impact.
-5. Update docs when CLI behavior changes.
-
-## Bug report checklist
-
-Include:
-
-1. DCR version (`dcr --version`).
-2. OS and compiler/toolchain version.
-3. Reproduction steps.
-4. Expected result.
-5. Actual result and full error output.
-6. Minimal reproducible project.
-
-## Where to report
-
-Use GitHub Issues in the relevant repository:
-
-- <https://github.com/dexoron/dcr>
-- <https://github.com/dexoron/dcr-site>

docs/reference-and-help/faq.md

@@ -1,34 +0,0 @@
-# FAQ
-
-## What commands are available?
-
-`new`, `init`, `build`, `run`, `clean`, `--help`, `--version`, `--update`.
-
-## Is `dcr.toml` mandatory?
-
-Yes, for `build`, `run`, and `clean`.
-
-## What source files are compiled?
-
-DCR scans `src/` recursively:
-
-- for C: `*.c`
-- for C++: `*.cpp`, `*.cxx`, `*.cc`
-
-## Can I switch compiler?
-
-Yes. Set `build.compiler` in `dcr.toml` (for example `gcc`, `clang`, `cl`, `clang-cl`).
-
-## How does incremental rebuild work?
-
-It compares source file mtime with object file mtime. Header dependency tracking is not implemented yet.
-
-## What does `dcr run` do if build fails?
-
-It tries to run an existing binary from the selected profile; if none exists, it reports an error.
-
-## How do I update DCR?
-
-Use `dcr --update` for non-package-managed installs.
-
-If installed through pacman/AUR, update via package manager.

docs/reference/build-profiles.mdx

@@ -0,0 +1,55 @@
+---
+sidebar_label: Build profiles
+---
+
+# Build Profiles
+
+Profiles allow overriding `[build]` fields for specific build modes.
+
+## Configuration
+
+```toml
+[build]
+language = "c"
+standard = "c17"
+cflags = ["-Wall"]
+
+[build.debug]
+cflags = ["-O0", "-g"]
+
+[build.release]
+cflags = ["-O3", "-DNDEBUG"]
+```
+
+## Merge rules
+
+Fields from `[build.<profile>]` are merged on top of `[build]`:
+
+- **Scalar fields** (strings, numbers, bools) — replaced
+- **Arrays** (`cflags`, `ldflags`, ...) — **appended** (extend the `[build]` array)
+
+Set `inherit = false` to disable array inheritance (only profile's own arrays are used).
+
+## Built-in profiles
+
+| Profile | Default cflags |
+|---------|---------------|
+| `debug` | `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG` |
+| `release` | `-O3 -DNDEBUG` |
+
+## Target-specific profiles
+
+```toml
+[build.linux]
+cflags = ["-DLINUX"]
+
+[build.windows.debug]
+cflags = ["-DWIN32", "-O0", "-g"]
+```
+
+Application order (highest priority first):
+1. `[build.<target>.<profile>]`
+2. `[build.<profile>.<target>]`
+3. `[build.<target>]`
+4. `[build.<profile>]`
+5. `[build]`

docs/reference/build-system.mdx

@@ -0,0 +1,101 @@
+---
+sidebar_label: Build system
+---
+
+# Build System
+
+## Compiler Backends
+
+DCR supports 4 compilation backends. Selection is automatic based on file extension.
+
+| Backend | Files | When used |
+|---------|-------|-----------|
+| `unix_cc` | `.c`, `.cpp`, `.cxx`, `.cc`, `.S` | gcc/clang on Linux/macOS/BSD |
+| `msvc` | `.c`, `.cpp`, `.cxx`, `.cc` | Windows (cl, clang-cl) |
+| `gas` | `.s` | ARM/ARM64 assembler (no preprocessor) |
+| `nasm` | `.asm` | x86/x86_64 assembler |
+
+### Unix CC
+
+- Compiler resolved via `resolve_compiler()`: `DCR_COMPILER` > `DCR_CC` > `[toolchain]` > `build.compiler` > `PATH`
+- Supports `.d` files for header dependency tracking
+- Flags: `-std=`, `-MMD -MF`, `-c -o`, `-I`, `-L`, `-l`
+
+### MSVC
+
+- Supports cl.exe and clang-cl.exe
+- Flags: `/std:`, `/Fo:`, `/Fe:`, `/I`, `/link`
+
+### GAS / NASM
+
+- GAS: `-I`, `-c -o`, `--defsym`
+- NASM: `-I`, `-o`, `-D`, `-f` (format: win64/elf64/macho64/macho32/elf32)
+
+## Incremental Builds
+
+Three levels of incrementality:
+
+1. **mtime** — if output is newer than all inputs, skip
+2. **`.d` files** — header change tracking (including transitive)
+3. **SHA256 fingerprint** — recompile if compiler flags changed (stored in `.dcr_fingerprint`)
+
+## Parallel Compilation
+
+- `thread::scope` for thread pool
+- Atomic task queue (`AtomicU64`)
+- Mutex on stdout (`OUTPUT_MUTEX`)
+- Thread count = `available_parallelism()`
+
+## Build Kinds
+
+| Kind | Type | Path (Linux example) |
+|------|------|---------------------|
+| `bin` | Executable | `target/<triple>/<profile>/<name>` (.exe on Windows) |
+| `staticlib` | Static library | `target/<triple>/<profile>/lib<name>.a` (.lib) |
+| `sharedlib` | Dynamic library | `target/<triple>/<profile>/lib<name>.so` (.dll/.dylib) |
+| `efi` | UEFI application | `target/<triple>/<profile>/<name>.efi` |
+| `elf` | ELF without stdlib | `target/<triple>/<profile>/<name>` |
+| `none` | Compile only, no link | — |
+| `custom` | Full filename+extension control | `target/<triple>/<profile>/<filename>.<extension>` |
+
+## Build Steps
+
+DCR supports pre-build and post-build steps:
+
+- `build.steps` — commands before compilation
+- `build.post_steps` — commands after compilation
+
+Substitutions: `{stem}`, `{in}`, `{out}`, `{profile}`, `{version}`, `{name}`.
+
+Example Qt codegen via build steps:
+
+```toml
+[build.steps]
+moc = "moc {in} -o {out}"
+```
+
+## pkg-config
+
+Automatic lookup (read from raw config):
+
+```toml
+[build]
+pkg_config = ["sdl2", "gl"]
+```
+
+DCR runs `pkg-config --cflags sdl2 gl` and `pkg-config --libs sdl2 gl` and adds results to compiler/linker flags.
+
+## Variable Substitution
+
+Supported variables:
+
+| Variable | Description |
+|----------|-------------|
+| `{version}` | Package version |
+| `{version_major}` | Major version part |
+| `{version_minor}` | Minor version part |
+| `{version_patch}` | Patch version |
+| `{version_suffix}` | Suffix (e.g., `-rc1`) |
+| `{version_suffix_dash}` | Suffix with dash |
+| `{profile}` | Profile name (debug/release) |
+| `{name}` | Package name |

docs/reference/cross-compilation.mdx

@@ -0,0 +1,60 @@
+---
+sidebar_label: Cross-compilation
+---
+
+# Cross-Compilation
+
+## Short Names
+
+DCR supports short platform names:
+
+| Short Name | Full Triple |
+|-----------|-------------|
+| `linux` | `x86_64-unknown-linux-gnu` |
+| `macos` | `x86_64-apple-darwin` |
+| `windows` | `x86_64-pc-windows-msvc` |
+
+```bash
+dcr build --target windows
+```
+
+## Full Triples
+
+```bash
+dcr build --target aarch64-unknown-linux-gnu
+dcr build --target x86_64-pc-windows-gnu      # mingw
+dcr build --target armv7-unknown-linux-gnueabihf
+```
+
+## clang --target
+
+When using clang, DCR injects `--target=<triple>` into CFLAGS.
+
+```toml
+[build]
+compiler = "clang"
+target = "aarch64-unknown-linux-gnu"
+# Auto: cflags += ["--target=aarch64-unknown-linux-gnu"]
+```
+
+## Bare-Metal
+
+For targets containing `none`, `-elf`, `eabi`, or `baremetal`, DCR default flags are disabled (no system include paths, no `-l` libc).
+
+```bash
+dcr build --target aarch64-none-elf
+```
+
+## Target Directory
+
+On Linux with explicit target:
+
+```
+target/<triple>/<profile>/
+```
+
+On macOS/Windows or without target:
+
+```
+target/<profile>/
+```

docs/reference/dcr-toml.mdx

@@ -0,0 +1,132 @@
+---
+sidebar_label: dcr.toml overview
+---
+
+# dcr.toml
+
+Main project configuration file. Located at the project root.
+
+## Structure
+
+```toml
+[package]
+# required fields
+
+[build]
+# build settings
+
+[build.debug]       # optional: debug override
+[build.release]     # optional: release override
+
+[build.linux]       # optional: Linux override
+[build.windows]     # optional: Windows override
+[build.windows.debug]  # target + profile combination
+
+[toolchain]
+# compiler/linker paths
+
+[dependencies]
+# project dependencies
+
+[workspace]
+# multi-package configuration
+
+[run]
+# run settings
+```
+
+## [package]
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | yes | Project name |
+| `version` | yes | Semantic version |
+| `type` | yes | `app`, `lib`, `none` |
+| `license` | no | SPDX license identifier |
+| `author` | no | Author |
+
+```toml
+[package]
+name = "my-app"
+version = "0.1.0"
+type = "app"
+license = "MIT"
+author = "John Doe"
+```
+
+## [build]
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `language` | `"c"` | `"c"`, `"c++"`, `"cpp"`, `"cxx"`, `"asm"` |
+| `standard` | `"c11"` | C standard (`c11`, `c17`, `c23`) |
+| `cxx_standard` | `"c++20"` | C++ standard (`c++17`, `c++20`, `c++23`) |
+| `compiler` | `"clang"` | Preferred compiler |
+| `kind` | `"bin"` | `bin`, `staticlib`, `sharedlib`, `efi`, `elf`, `none`, `custom` |
+| `target` | host | Target triple for cross-compilation |
+| `platform` | `"native"` | `native`, `efi`, `freestanding` |
+| `cflags` | `[]` | Additional C/C++/ASM flags |
+| `ldflags` | `[]` | Additional linker flags |
+| `filename` | `""` | Custom output file name |
+| `extension` | `""` | Custom file extension |
+| `roots` | `["src"]` | Source root directories |
+| `exclude` | `[]` | Exclude patterns |
+| `include` | `[]` | Additional include directories |
+| `src_disable` | `false` | Disable auto source discovery |
+| `inherit` | `false` | Inherit build from workspace root |
+| `clean` | `[]` | Glob patterns for custom clean paths |
+| `out_dir` | `""` | Custom output directory |
+| `workspace_only` | `false` | Workspace-only, not built standalone |
+
+Settings from raw config (not in typed struct):
+- `pkg_config` — list of pkg-config packages
+- `ldscript` — linker script path
+- `build.steps` / `build.post_steps` — codegen steps
+
+Example:
+
+```toml
+[build]
+language = "c++"
+standard = "c23"
+cxx_standard = "c++23"
+compiler = "clang"
+kind = "sharedlib"
+cflags = ["-Wall", "-Wextra"]
+```
+
+## [toolchain]
+
+```toml
+[toolchain]
+cc = "/usr/bin/clang"
+cxx = "/usr/bin/clang++"
+as = "/usr/bin/as"
+ar = "/usr/bin/ar"
+ld = "/usr/bin/ld.lld"
+```
+
+Raw config also supports `uic`, `moc`, `rcc` for Qt codegen.
+
+## [dependencies]
+
+See [dependencies](/docs/reference/dependencies).
+
+## [run]
+
+```toml
+[run]
+cmd = "./target/{profile}/{name}"
+```
+
+Substitutions:
+- `{version}` — package version
+- `{version_major}`, `{version_minor}`, `{version_patch}`, `{version_suffix}`, `{version_suffix_dash}` — version parts
+- `{profile}` — debug / release
+- `{name}` — package name
+
+Default `cmd` = `./target/{profile}/{name}` (macOS/Windows) or `./target/<triple>/<profile>/<name>` (Linux).
+
+## [workspace]
+
+See [workspaces](/docs/reference/workspaces).

docs/reference/dependencies.mdx

@@ -0,0 +1,84 @@
+---
+sidebar_label: Dependencies
+---
+
+# Dependencies
+
+## Formats
+
+The `[dependencies]` section supports three formats:
+
+### String (registry)
+
+```toml
+[dependencies]
+fmt = "10.1.1"
+spdlog = "1.12"
+catch2 = "3.4.0"
+```
+
+The version string is used as-is for registry lookup.
+
+### Table (git)
+
+```toml
+[dependencies]
+fmt = { git = "https://github.com/fmtlib/fmt", tag = "10.1.1" }
+```
+
+Fields: `git`, `branch`, `tag`, `rev`.
+
+### Table (path)
+
+```toml
+[dependencies]
+mylib = { path = "../mylib" }
+```
+
+## Registry
+
+DCR uses a package registry for dependency lookup by name.
+
+```toml
+# ~/.dcr/config.toml
+[[registry]]
+name = "default"
+url = "https://index.dcr.pm"
+```
+
+Registry priority: order in `config.toml`. The `DCR_INDEX_PATH` variable overrides the path to `index.json`.
+
+## Git dependencies
+
+DCR clones git repositories via `git2`:
+
+- `branch` — switch to a branch
+- `tag` — switch to a tag
+- `rev` — switch to a specific commit
+- `features` — feature flags (parsed, but does not affect build)
+
+Cache path: `~/.dcr/git/<hash>/`.
+
+## Path dependencies
+
+Local paths. DCR automatically discovers include and lib directories from the neighbor's `dcr.toml`.
+
+```toml
+[dependencies]
+mylib = { path = "/abs/path/to/lib" }
+mylib = { path = "../relative/path" }
+```
+
+## dcr.lock
+
+Dependency lock file. Contains package names and sources.
+
+Created during `dcr build` when registry dependencies are present. Not updated during `dcr add` — only on the next `dcr build`.
+
+## Resolution process
+
+1. Load all dependencies (registry → git → path)
+2. For path deps: recursively read their `dcr.toml`
+3. For registry deps: search `index.json`
+4. For git deps: clone to cache
+5. Collect `include_dirs`, `lib_dirs`, `libs` for the compiler

docs/reference/environment-variables.mdx

@@ -0,0 +1,59 @@
+---
+sidebar_label: Environment variables
+---
+
+# Environment Variables
+
+## DCR_COMPILER
+
+Overrides the compiler for all languages. **Highest priority.**
+
+```bash
+export DCR_COMPILER=clang
+dcr build
+```
+
+Compiler resolution priority:
+1. `DCR_COMPILER` (env)
+2. `DCR_CC` / `DCR_CXX` / `DCR_AS` (env)
+3. `[toolchain]` (dcr.toml)
+4. `build.compiler` (dcr.toml)
+5. `PATH`
+
+## DCR_CC / DCR_CXX / DCR_AS
+
+Per-language override (lower priority than `DCR_COMPILER`, higher than `[toolchain]`).
+
+```bash
+export DCR_CC=gcc-14
+export DCR_CXX=g++-14
+export DCR_AS=arm-linux-gnueabihf-as
+```
+
+## DCR_LD / DCR_AR
+
+Override linker and archiver.
+
+```bash
+export DCR_LD=ld.lld
+export DCR_AR=llvm-ar
+```
+
+## DCR_DEBUG
+
+Enables debug mode — prints all compilation commands to stderr before execution.
+
+```bash
+export DCR_DEBUG=1
+dcr build
+```
+
+## DCR_INDEX_PATH
+
+Overrides the path to the registry `index.json`.
+
+```bash
+export DCR_INDEX_PATH=/custom/path/index.json
+```
+
+Default: `~/.dcr/index.json`.

docs/reference/platform-support.mdx

@@ -0,0 +1,51 @@
+---
+sidebar_label: Platform support
+---
+
+# Platform Support
+
+## Target Triples
+
+DCR normalizes target triples. Short platform names are expanded to full triples.
+
+### Linux
+
+```
+target/<arch>-unknown-linux-gnu/<profile>/
+```
+
+Architectures: `x86_64`, `aarch64` (host-detected).
+
+Artifact type: ELF. Extensions: `.so` (sharedlib), `.a` (staticlib).
+
+### macOS
+
+```
+target/<profile>/
+```
+
+Architectures: `x86_64`, `aarch64` (host-detected).
+
+Extensions: `.dylib` (sharedlib), `.a` (staticlib).
+
+### Windows
+
+```
+target/<profile>/
+```
+
+Architectures: `x86_64`, `aarch64`.
+
+Extensions: `.exe` (bin), `.lib` (staticlib), `.dll` (sharedlib), `.efi` (UEFI).
+
+### BSD
+
+```
+target/<arch>-unknown-<os>/<profile>/
+```
+
+Supported systems: `freebsd`, `openbsd`, `netbsd`, `dragonfly`.
+
+## Host Detection
+
+DCR uses `std::env::consts::ARCH` and `std::env::consts::OS` for host platform detection. Used as fallback when `target` is not specified.

docs/reference/workspaces.mdx

@@ -0,0 +1,67 @@
+---
+sidebar_label: Workspaces
+---
+
+# Workspaces
+
+Workspaces allow managing multiple packages in a single repository.
+
+## Configuration
+
+```toml
+[workspace.lib-core]
+path = "lib-core"
+
+[workspace.lib-utils]
+path = "lib-utils"
+deps = ["lib-core"]
+
+[workspace.app]
+path = "app"
+deps = ["lib-core", "lib-utils"]
+main = true
+```
+
+### Member fields
+
+| Field | Description |
+|-------|-------------|
+| `path` | Path to the package (relative to workspace root) |
+| `deps` | Dependencies on other members |
+| `main` | Mark as the main package |
+
+## Topological sort
+
+DCR automatically sorts packages by dependencies: package A is built before B if B depends on A.
+
+Cyclic dependencies are detected and cause an error.
+
+## Build
+
+```bash
+dcr build                    # build all packages in dependency order
+dcr build --workspace app    # build only app (dependencies built automatically)
+```
+
+When building a workspace, member outputs (libraries) are automatically added to include/lib paths of dependent packages.
+
+## Clean
+
+```bash
+dcr clean                    # clean only root target/
+dcr clean --all              # clean target/ of all packages
+```
+
+## Inheritance
+
+If a member has `inherit = true` in its `[build]` section, fields from the root `[build]` are merged into the member:
+
+```toml
+# root dcr.toml
+[build]
+inherit = true
+language = "c"
+standard = "c17"
+
+# member inherits language and standard
+```

docs/self-update.mdx

@@ -0,0 +1,46 @@
+---
+sidebar_label: Self Update
+---
+
+# Self Update
+
+## dcr --update
+
+Automatic update to the latest version. Downloads a binary (not an archive) from GitHub Releases and replaces the current executable.
+
+```bash
+dcr --update
+```
+
+## How it works
+
+1. DCR detects the current platform and architecture
+2. Fetches the latest release from `api.github.com/repos/dexoron/dcr/releases/latest`
+3. Compares versions
+4. Downloads the matching asset (direct binary URL, not archive)
+5. Replaces the current executable via `self_replace`
+
+## Asset naming
+
+Pattern: `dcr-<triple>` or `dcr-<triple>.exe`
+
+| Platform | Asset name |
+|----------|-----------|
+| Linux x86_64 | `dcr-x86_64-unknown-linux-gnu` |
+| macOS x86_64 | `dcr-x86_64-apple-darwin` |
+| macOS ARM64 | `dcr-aarch64-apple-darwin` |
+| Windows x86_64 | `dcr-x86_64-pc-windows-msvc.exe` |
+
+## AUR
+
+If DCR was installed via AUR, `--update` shows a warning:
+
+```
+Update via package manager: yay/paru -Syu {package_name} or sudo pacman -Syu {package_name}
+```
+
+## Errors
+
+- Cannot detect platform — error
+- Cannot fetch release — error with URL
+- No write permission — error (use `sudo` or manual install)

docs/testing/running-tests.mdx

@@ -0,0 +1,45 @@
+---
+sidebar_label: Running tests
+---
+
+# Running Tests
+
+## Execution
+
+```bash
+dcr test
+```
+
+Builds the project, then compiles and runs test files from `tests/`.
+
+## Profiles
+
+```bash
+dcr test                     # debug (default)
+dcr test --release           # release
+dcr test --debug             # explicit debug
+```
+
+## Output
+
+```
+=====================
+  Testsuite summary
+=====================
+TOTAL: 5
+PASS: 3
+SKIP: 1
+FAIL: 1
+=====================
+```
+
+## Exit code
+
+- 0 — all tests passed (FAIL = 0)
+- 1 — test failures or build error
+
+## What gets built
+
+- All `.c` files from `tests/` (`.cpp` not supported)
+- Include path: `tests/` (for `dcr_test.h`)
+- Linked with project if `package.type = "lib"` or `kind = "staticlib"`/`"sharedlib"`

docs/testing/test-framework.mdx

@@ -0,0 +1,68 @@
+---
+sidebar_label: Test framework (EXPECT, TEST, ...)
+---
+
+# Test Framework
+
+DCR has a built-in minimal test framework for C.
+
+## Macros
+
+### `EXPECT(expr)`
+
+Asserts that an expression is true.
+
+```c
+EXPECT(1 + 1 == 2);
+EXPECT(ptr != NULL);
+```
+
+### `SKIP(reason)`
+
+Skips a test with a message.
+
+```c
+SKIP("not implemented on Windows");
+```
+
+### `TEST(name)`
+
+Defines a test.
+
+```c
+TEST(addition) {
+    EXPECT(1 + 1 == 2);
+    EXPECT(2 + 2 == 4);
+}
+```
+
+### `TEST_CASE(name)`
+
+Registers a test case.
+
+```c
+TEST_CASE(math) {
+    EXPECT(1 + 1 == 2);
+}
+```
+
+## Initialization
+
+```bash
+dcr test --init
+```
+
+Creates:
+- `tests/dcr_test.h` — framework header (do not edit)
+- `tests/test.c` — template with example test
+
+## Structure
+
+```
+tests/
+├── dcr_test.h      # framework (do not edit)
+├── test.c          # main tests
+└── ...             # additional .c test files
+```
+
+Only `.c` files are compiled (`.cpp` is not supported).

flake.lock

@@ -0,0 +1,135 @@
+{
+  "nodes": {
+    "fenix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "rust-analyzer-src": "rust-analyzer-src"
+      },
+      "locked": {
+        "lastModified": 1780218205,
+        "narHash": "sha256-c4MSlBQw5MIDRkad9UNUUnBaOHAHnhuCXrDt90FDVrg=",
+        "owner": "nix-community",
+        "repo": "fenix",
+        "rev": "96e0fc9f1a9b37f6477fa11c3fd48575354773ed",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "fenix",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1779560665,
+        "narHash": "sha256-tpyBcxPpcQb8ukyNF7DoCwfSY3VPsxHoYwj00Cayv5o=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "64c08a7ca051951c8eae34e3e3cb1e202fe36786",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1770107345,
+        "narHash": "sha256-tbS0Ebx2PiA1FRW8mt8oejR0qMXmziJmPaU1d4kYY9g=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "4533d9293756b63904b7238acb84ac8fe4c8c2c4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "fenix": "fenix",
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "treefmt-nix": "treefmt-nix"
+      }
+    },
+    "rust-analyzer-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1780179631,
+        "narHash": "sha256-61A3gj4V1DyPP6lVHTdui4+dvG66pkMZSMd1Kke3Rz8=",
+        "owner": "rust-lang",
+        "repo": "rust-analyzer",
+        "rev": "cce33f2f1565958787bb763ae751a6a5f56b95e3",
+        "type": "github"
+      },
+      "original": {
+        "owner": "rust-lang",
+        "ref": "nightly",
+        "repo": "rust-analyzer",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "treefmt-nix": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1780220602,
+        "narHash": "sha256-eynAfOmbmxJnkp7YewvCEbShNnnYJ9gLLqkzsYtBPeM=",
+        "owner": "numtide",
+        "repo": "treefmt-nix",
+        "rev": "db947814a175b7ca6ded66e21383d938df01c227",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "treefmt-nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,111 @@
+{
+  description = "DCR — Cargo-like utility for managing C/C++ projects";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    flake-utils.url = "github:numtide/flake-utils";
+
+    treefmt-nix.url = "github:numtide/treefmt-nix";
+
+    fenix = {
+      url = "github:nix-community/fenix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs = {
+    self,
+    nixpkgs,
+    flake-utils,
+    treefmt-nix,
+    fenix,
+  }:
+    flake-utils.lib.eachDefaultSystem (system: let
+      pkgs = import nixpkgs {
+        inherit system;
+      };
+
+      cargoToml = builtins.fromTOML (builtins.readFile ./Cargo.toml);
+      packageName = cargoToml.package.name;
+      packageVersion = cargoToml.package.version;
+
+      rustToolchain = fenix.packages.${system}.stable.toolchain;
+
+      rustPlatform = pkgs.makeRustPlatform {
+        cargo = rustToolchain;
+        rustc = rustToolchain;
+      };
+
+      treefmtEval = treefmt-nix.lib.evalModule pkgs {
+        projectRootFile = "flake.nix";
+
+        programs.alejandra.enable = true;
+        programs.rustfmt.enable = true;
+        programs.taplo.enable = true;
+      };
+
+      app = rustPlatform.buildRustPackage {
+        pname = packageName;
+        version = packageVersion;
+
+        src = ./.;
+
+        cargoLock.lockFile = ./Cargo.lock;
+
+        nativeBuildInputs = [
+          pkgs.pkg-config
+          pkgs.cmake
+          pkgs.perl
+        ];
+
+        buildInputs = pkgs.lib.optionals pkgs.stdenv.isDarwin [
+          pkgs.darwin.apple_sdk.frameworks.Security
+          pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
+        ];
+
+        # Tests require external services; run separately.
+        doCheck = false;
+      };
+    in {
+      packages = {
+        default = app;
+        dcr = app;
+      };
+
+      apps = let
+        defaultApp =
+          (flake-utils.lib.mkApp {
+            drv = app;
+          })
+          // {
+            meta.description = "Run ${packageName}";
+          };
+      in {
+        default = defaultApp;
+        dcr = defaultApp;
+      };
+
+      checks = {
+        dcr = app;
+        formatting = treefmtEval.config.build.check self;
+      };
+
+      formatter = treefmtEval.config.build.wrapper;
+
+      devShells.default = pkgs.mkShell {
+        inputsFrom = [app];
+
+        packages = [
+          rustToolchain
+          pkgs.rust-analyzer
+
+          treefmtEval.config.build.wrapper
+        ];
+
+        shellHook = ''
+          export RUST_SRC_PATH="${rustToolchain}/lib/rustlib/src/rust/library"
+        '';
+      };
+    });
+}

install.ps1

@@ -1,7 +1,8 @@
 $ErrorActionPreference = 'Stop'
 
 $RepoUrl    = 'https://github.com/dexoron/dcr'
-$ApiUrl = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
+$ApiLatest  = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
+$ApiAll     = 'https://api.github.com/repos/dexoron/dcr/releases'
 $InstallPath = Join-Path $env:LOCALAPPDATA 'dcr'
 $BinPath     = Join-Path $env:USERPROFILE '.local\bin'
 $BinaryPath  = Join-Path $InstallPath 'dcr.exe'
@@ -17,6 +18,20 @@ function Require-Cmd($name) {
     }
 }
 
+function Select-Channel {
+    Write-Host "Choose channel:"
+    Write-Host "  1) Latest stable release (default)"
+    Write-Host "  2) Latest dev (pre-release)"
+    $choice = Read-Host "Enter 1 or 2 [1]"
+    if ([string]::IsNullOrWhiteSpace($choice)) { $choice = '1' }
+
+    switch ($choice) {
+        '1' { return 'stable' }
+        '2' { return 'dev'    }
+        default { Fail 'Unknown option' }
+    }
+}
+
 function Select-Mode {
     Write-Host "Choose installation mode:"
     Write-Host "  1) Download prebuilt binary from GitHub Release (recommended)"
@@ -32,24 +47,47 @@ function Select-Mode {
 }
 
 function Get-Target {
-    if ($env:PROCESSOR_ARCHITECTURE -ne 'AMD64') {
+    $arch = $env:PROCESSOR_ARCHITECTURE
-        Fail "Only x86_64 Windows is supported, current architecture: $env:PROCESSOR_ARCHITECTURE"
+    if ($env:PROCESSOR_ARCHITEW6432) {
+        $arch = $env:PROCESSOR_ARCHITEW6432
+    }
+    switch ($arch) {
+        'AMD64' { return 'x86_64-pc-windows-msvc' }
+        'ARM64' { return 'aarch64-pc-windows-msvc' }
+        'x86'   { return 'i686-pc-windows-msvc' }
+        default { Fail "Unsupported Windows architecture: $arch" }
+    }
+}
+
+function Fetch-ReleaseJson($channel) {
+    if ($channel -eq 'dev') {
+        Info "Looking for latest dev (pre-release)..."
+        $releases = Invoke-RestMethod -Method Get -Uri $ApiAll
+        $pre = $releases | Where-Object { $_.prerelease -eq $true } | Select-Object -First 1
+        if (-not $pre) { Fail "No dev (pre-release) found on GitHub" }
+        return $pre
+    } else {
+        return Invoke-RestMethod -Method Get -Uri $ApiLatest
     }
-    return 'x86_64-pc-windows-msvc'
 }
 
 function Install-FromRelease {
-    param([string]$target)
+    param([string]$target, [string]$channel)
 
     New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null
 
-    $assetName = "dcr-$target.exe"
+    $release = Fetch-ReleaseJson $channel
-    Info "Fetching latest release..."
+    $tag     = $release.tag_name
-    $release = Invoke-RestMethod -Method Get -Uri $ApiUrl
+    $version = $tag.TrimStart('v')
+
+    # Имя бинарника: dcr-<triple>-<version>.exe
+    $assetName = "dcr-$target-$version.exe"
+
+    Info "Fetching release $tag (channel: $channel)..."
 
     $asset = $release.assets | Where-Object { $_.name -eq $assetName } | Select-Object -First 1
     if (-not $asset) {
-        Fail "Asset $assetName not found in release $($release.tag_name)"
+        Fail "Asset $assetName not found in release $tag"
     }
 
     Info "Downloading $assetName..."
@@ -58,7 +96,7 @@ function Install-FromRelease {
 }
 
 function Install-FromSource {
-    param([string]$target)
+    param([string]$target, [string]$channel)
 
     Require-Cmd 'git'
     Require-Cmd 'cargo'
@@ -67,7 +105,15 @@ function Install-FromSource {
     if (Test-Path $tmp) { Remove-Item -Recurse -Force $tmp }
 
     Info 'Cloning repository...'
+    if ($channel -eq 'dev') {
+        # Пробуем ветку dev
+        $result = git clone --depth 1 --branch dev $RepoUrl $tmp 2>&1
+        if ($LASTEXITCODE -ne 0) {
             git clone --depth 1 $RepoUrl $tmp | Out-Null
+        }
+    } else {
+        git clone --depth 1 $RepoUrl $tmp | Out-Null
+    }
 
     Info 'Building release binary...'
     Push-Location $tmp
@@ -100,13 +146,14 @@ function Setup-Path {
 }
 
 Info 'Starting DCR installation'
+$channel = Select-Channel
 $mode    = Select-Mode
 $target  = Get-Target
 
 if ($mode -eq 'build') {
-    Install-FromSource -target $target
+    Install-FromSource -target $target -channel $channel
 } else {
-    Install-FromRelease -target $target
+    Install-FromRelease -target $target -channel $channel
 }
 
 Setup-Path

install.sh

@@ -6,7 +6,8 @@ INSTALL_PATH="$HOME/.local/share/dcr"
 BINPATH="$HOME/.local/bin"
 LOGFILE="$HOME/.cache/dcr-install.log"
 REPO_URL="https://github.com/dexoron/dcr"
-GITHUB_API="https://api.github.com/repos/dexoron/dcr/releases/latest"
+GITHUB_API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
+GITHUB_API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
 
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -24,10 +25,13 @@ error() { echo -e "${RED}✖ $1${NC}"; }
 
 trap 'error "Error on line $LINENO"; exit 1' ERR
 
+INSTALL_MODE=""
+CHANNEL=""
+
 check_os() {
     case "$(uname -s)" in
-        Linux|Darwin) ;;
+        Linux|Darwin|FreeBSD|OpenBSD|NetBSD) ;;
-        *) error "Only Linux and macOS are supported"; exit 1 ;;
+        *) error "Only Linux, macOS, and BSD systems are supported"; exit 1 ;;
     esac
 }
 
@@ -38,16 +42,34 @@ detect_target() {
 
     case "$os:$arch" in
         Linux:x86_64)                      TARGET_TRIPLE="x86_64-unknown-linux-gnu" ;;
+        Linux:aarch64|Linux:arm64)         TARGET_TRIPLE="aarch64-unknown-linux-gnu" ;;
+        Linux:i686|Linux:i386)             TARGET_TRIPLE="i686-unknown-linux-gnu" ;;
+        Linux:armv7l|Linux:armv7)          TARGET_TRIPLE="armv7-unknown-linux-gnueabihf" ;;
+        Linux:riscv64)                     TARGET_TRIPLE="riscv64gc-unknown-linux-gnu" ;;
         Darwin:x86_64)                     TARGET_TRIPLE="x86_64-apple-darwin" ;;
         Darwin:arm64|Darwin:aarch64)       TARGET_TRIPLE="aarch64-apple-darwin" ;;
+        FreeBSD:x86_64|FreeBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-freebsd" ;;
+        FreeBSD:aarch64|FreeBSD:arm64)     TARGET_TRIPLE="aarch64-unknown-freebsd" ;;
+        FreeBSD:i686|FreeBSD:i386)         TARGET_TRIPLE="i686-unknown-freebsd" ;;
+        OpenBSD:x86_64|OpenBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-openbsd" ;;
+        OpenBSD:aarch64|OpenBSD:arm64)     TARGET_TRIPLE="aarch64-unknown-openbsd" ;;
+        OpenBSD:i686|OpenBSD:i386)         TARGET_TRIPLE="i686-unknown-openbsd" ;;
+        NetBSD:x86_64|NetBSD:amd64)        TARGET_TRIPLE="x86_64-unknown-netbsd" ;;
+        NetBSD:aarch64|NetBSD:arm64)       TARGET_TRIPLE="aarch64-unknown-netbsd" ;;
+        NetBSD:i686|NetBSD:i386)           TARGET_TRIPLE="i686-unknown-netbsd" ;;
+
         *) error "Unsupported platform: $os/$arch"; exit 1 ;;
     esac
-
-    ASSET_NAME="dcr-${TARGET_TRIPLE}"
 }
 
 check_common_dependencies() {
     command -v curl >/dev/null 2>&1 || { error "curl is not installed"; exit 1; }
+    if [[ "$CHANNEL" == "dev" ]]; then
+        if ! command -v python3 >/dev/null 2>&1 && ! command -v jq >/dev/null 2>&1; then
+            error "For dev installations, either 'python3' or 'jq' must be installed to parse GitHub API response."
+            exit 1
+        fi
+    fi
 }
 
 check_build_dependencies() {
@@ -55,10 +77,105 @@ check_build_dependencies() {
     command -v cargo >/dev/null 2>&1 || { error "cargo is not installed"; exit 1; }
 }
 
+select_channel() {
+    echo "Choose channel:"
+    echo "  1) Latest stable release (default)"
+    echo "  2) Latest dev (pre-release)"
+    read -r -p "Enter 1 or 2 [1]: " choice < /dev/tty
+
+    case "${choice:-1}" in
+        1) CHANNEL="stable" ;;
+        2) CHANNEL="dev"    ;;
+        *) error "Unknown option"; exit 1 ;;
+    esac
+}
+
+select_install_mode() {
+    echo "Choose installation mode:"
+    echo "  1) Download prebuilt binary from GitHub Release (recommended)"
+    echo "  2) Build from git"
+    read -r -p "Enter 1 or 2 [1]: " choice < /dev/tty
+
+    case "${choice:-1}" in
+        1) INSTALL_MODE="release" ;;
+        2) INSTALL_MODE="build"   ;;
+        *) error "Unknown option"; exit 1 ;;
+    esac
+}
+
+# Returns JSON of the requested release to stdout
+fetch_release_json() {
+    if [[ "$CHANNEL" == "dev" ]]; then
+        log "Looking for latest dev (pre-release)..."
+        local json result
+        json="$(curl -fsSL "$GITHUB_API_ALL")"
+        if command -v jq >/dev/null 2>&1; then
+            result="$(printf '%s' "$json" | jq -e -c 'map(select(.prerelease == true))[0]')"
+        else
+            result="$(printf '%s' "$json" | python3 - <<'EOF'
+import sys, json
+releases = json.load(sys.stdin)
+pre = [r for r in releases if r.get("prerelease", False)]
+if not pre:
+    print("{}", end="")
+else:
+    print(json.dumps(pre[0]), end="")
+EOF
+)"
+        fi
+
+        if [[ -z "$result" || "$result" == "{}" || "$result" == "null" ]]; then
+            error "No dev (pre-release) found on GitHub"
+            exit 1
+        fi
+        printf '%s' "$result"
+    else
+        curl -fsSL "$GITHUB_API_LATEST"
+    fi
+}
+
+download_binary() {
+    local release_json tag version asset_name download_url
+
+    release_json="$(fetch_release_json)"
+
+    tag="$(printf '%s\n' "$release_json" | \
+        sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
+    if [[ -z "$tag" ]]; then
+        error "Failed to determine release version"
+        exit 1
+    fi
+
+    # Version without leading 'v'
+    version="${tag#v}"
+    # Binary name: dcr-<triple>-<version>
+    asset_name="dcr-${TARGET_TRIPLE}-${version}"
+
+    log "Fetching release ${tag} (channel: ${CHANNEL})..."
+
+    download_url="$(printf '%s\n' "$release_json" | \
+        sed -n "s#.*\"browser_download_url\": \"\([^\"]*/${asset_name}\)\".*#\1#p" | head -n1)"
+
+    if [[ -z "$download_url" ]]; then
+        error "Asset ${asset_name} not found in release ${tag}"
+        exit 1
+    fi
+
+    mkdir -p "$INSTALL_PATH"
+    curl -fL "$download_url" -o "$INSTALL_PATH/dcr"
+    chmod +x "$INSTALL_PATH/dcr"
+    success "Binary ${asset_name} downloaded (${tag})"
+}
+
 prepare_sources() {
     log "Fetching sources..."
     rm -rf "$TMPDIR"
     git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    if [[ "$CHANNEL" == "dev" ]]; then
+        # Clone dev branch if it exists
+        git clone --depth 1 --branch dev "$REPO_URL" "$TMPDIR" 2>/dev/null || \
+        git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    fi
     success "Sources fetched"
 }
 
@@ -68,34 +185,6 @@ build_binary() {
     success "Build completed"
 }
 
-fetch_latest_release_json() {
-    curl -fsSL "$GITHUB_API"
-}
-
-download_binary() {
-    log "Fetching latest release..."
-
-    local release_json download_url tag
-    release_json="$(fetch_latest_release_json)"
-
-    tag="$(printf '%s\n' "$release_json" | sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
-    if [[ -z "$tag" ]]; then
-        error "Failed to determine release version"
-        exit 1
-    fi
-
-    download_url="$(printf '%s\n' "$release_json" | sed -n "s#.*\"browser_download_url\": \"\([^\"]*${ASSET_NAME}\)\".*#\1#p" | head -n1)"
-    if [[ -z "$download_url" ]]; then
-        error "Asset ${ASSET_NAME} not found in release ${tag}"
-        exit 1
-    fi
-
-    mkdir -p "$INSTALL_PATH"
-    curl -fL "$download_url" -o "$INSTALL_PATH/dcr"
-    chmod +x "$INSTALL_PATH/dcr"
-    success "Binary ${ASSET_NAME} downloaded (${tag})"
-}
-
 install_built_binary() {
     mkdir -p "$INSTALL_PATH"
     cp "$TMPDIR/target/release/dcr" "$INSTALL_PATH/dcr"
@@ -122,24 +211,12 @@ cleanup() {
     rm -rf "$TMPDIR" 2>/dev/null || true
 }
 
-select_install_mode() {
-    echo "Choose installation mode:"
-    echo "  1) Download prebuilt binary from GitHub Release (recommended)"
-    echo "  2) Build from git"
-    read -r -p "Enter 1 or 2 [1]: " choice
-
-    case "${choice:-1}" in
-        1) INSTALL_MODE="release" ;;
-        2) INSTALL_MODE="build" ;;
-        *) error "Unknown option"; exit 1 ;;
-    esac
-}
-
 main() {
     log "Starting DCR installation"
 
     check_os
     detect_target
+    select_channel
     check_common_dependencies
     select_install_mode
     cleanup

install_bsd.sh

@@ -0,0 +1,229 @@
+#!/bin/sh
+set -eu
+
+TMPDIR="/tmp/dcr-install"
+INSTALL_PATH="$HOME/.local/share/dcr"
+BINPATH="$HOME/.local/bin"
+LOGFILE="$HOME/.cache/dcr-install.log"
+REPO_URL="https://github.com/dexoron/dcr"
+GITHUB_API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
+GITHUB_API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+mkdir -p "$(dirname "$LOGFILE")"
+
+log()     { printf "${BLUE}[%s]${NC} %s\n" "$(date '+%Y-%m-%d %H:%M:%S')" "$1" | tee -a "$LOGFILE"; }
+success() { printf "${GREEN}✔ %s${NC}\n" "$1" | tee -a "$LOGFILE"; }
+warn()    { printf "${YELLOW}⚠ %s${NC}\n" "$1" | tee -a "$LOGFILE"; }
+error()   { printf "${RED}✖ %s${NC}\n" "$1" | tee -a "$LOGFILE" >&2; }
+
+INSTALL_MODE=""
+CHANNEL=""
+
+check_os() {
+    case "$(uname -s)" in
+        FreeBSD|OpenBSD|NetBSD|DragonFly) ;;
+        *) error "Only BSD systems (FreeBSD, OpenBSD, NetBSD, DragonFly) are supported by this script"; exit 1 ;;
+    esac
+}
+
+detect_target() {
+    local os arch
+    os="$(uname -s)"
+    arch="$(uname -m)"
+
+    case "$os:$arch" in
+        FreeBSD:x86_64|FreeBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-freebsd" ;;
+        FreeBSD:aarch64|FreeBSD:arm64)     TARGET_TRIPLE="aarch64-unknown-freebsd" ;;
+        FreeBSD:i686|FreeBSD:i386)         TARGET_TRIPLE="i686-unknown-freebsd" ;;
+        OpenBSD:x86_64|OpenBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-openbsd" ;;
+        OpenBSD:aarch64|OpenBSD:arm64)     TARGET_TRIPLE="aarch64-unknown-openbsd" ;;
+        OpenBSD:i686|OpenBSD:i386)         TARGET_TRIPLE="i686-unknown-openbsd" ;;
+        NetBSD:x86_64|NetBSD:amd64)        TARGET_TRIPLE="x86_64-unknown-netbsd" ;;
+        NetBSD:aarch64|NetBSD:arm64)       TARGET_TRIPLE="aarch64-unknown-netbsd" ;;
+        NetBSD:i686|NetBSD:i386)           TARGET_TRIPLE="i686-unknown-netbsd" ;;
+        DragonFly:x86_64|DragonFly:amd64)  TARGET_TRIPLE="x86_64-unknown-dragonfly" ;;
+        *) error "Unsupported BSD platform: $os/$arch"; exit 1 ;;
+    esac
+}
+
+check_common_dependencies() {
+    command -v curl >/dev/null 2>&1 || { error "curl is not installed"; exit 1; }
+    if [ "$CHANNEL" = "dev" ]; then
+        if ! command -v python3 >/dev/null 2>&1 && ! command -v jq >/dev/null 2>&1; then
+            error "For dev installations, either 'python3' or 'jq' must be installed to parse GitHub API response."
+            exit 1
+        fi
+    fi
+}
+
+check_build_dependencies() {
+    command -v git   >/dev/null 2>&1 || { error "git is not installed"; exit 1; }
+    command -v cargo >/dev/null 2>&1 || { error "cargo is not installed"; exit 1; }
+}
+
+select_channel() {
+    echo "Choose channel:"
+    echo "  1) Latest stable release (default)"
+    echo "  2) Latest dev (pre-release)"
+    printf "Enter 1 or 2 [1]: "
+    read -r choice
+
+    case "${choice:-1}" in
+        1) CHANNEL="stable" ;;
+        2) CHANNEL="dev"    ;;
+        *) error "Unknown option"; exit 1 ;;
+    esac
+}
+
+select_install_mode() {
+    echo "Choose installation mode:"
+    echo "  1) Download prebuilt binary from GitHub Release (recommended)"
+    echo "  2) Build from git"
+    printf "Enter 1 or 2 [1]: "
+    read -r choice
+
+    case "${choice:-1}" in
+        1) INSTALL_MODE="release" ;;
+        2) INSTALL_MODE="build"   ;;
+        *) error "Unknown option"; exit 1 ;;
+    esac
+}
+
+fetch_release_json() {
+    if [ "$CHANNEL" = "dev" ]; then
+        log "Looking for latest dev (pre-release)..."
+        local json result
+        json="$(curl -fsSL "$GITHUB_API_ALL")"
+        if command -v jq >/dev/null 2>&1; then
+            result="$(printf '%s' "$json" | jq -e -c 'map(select(.prerelease == true))[0]')"
+        else
+            result="$(printf '%s' "$json" | python3 - <<'EOF'
+import sys, json
+releases = json.load(sys.stdin)
+pre = [r for r in releases if r.get("prerelease", False)]
+if not pre:
+    print("{}", end="")
+else:
+    print(json.dumps(pre[0]), end="")
+EOF
+)"
+        fi
+
+        if [ -z "$result" ] || [ "$result" = "{}" ] || [ "$result" = "null" ]; then
+            error "No dev (pre-release) found on GitHub"
+            exit 1
+        fi
+        printf '%s' "$result"
+    else
+        curl -fsSL "$GITHUB_API_LATEST"
+    fi
+}
+
+download_binary() {
+    local release_json tag version asset_name download_url
+
+    release_json="$(fetch_release_json)"
+
+    tag="$(printf '%s\n' "$release_json" | \
+        sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
+    if [ -z "$tag" ]; then
+        error "Failed to determine release version"
+        exit 1
+    fi
+
+    version="${tag#v}"
+    asset_name="dcr-${TARGET_TRIPLE}-${version}"
+
+    log "Fetching release ${tag} (channel: ${CHANNEL})..."
+
+    download_url="$(printf '%s\n' "$release_json" | \
+        sed -n "s#.*\"browser_download_url\": \"\([^\"]*/${asset_name}\)\".*#\1#p" | head -n1)"
+
+    if [ -z "$download_url" ]; then
+        error "Asset ${asset_name} not found in release ${tag}"
+        exit 1
+    fi
+
+    mkdir -p "$INSTALL_PATH"
+    curl -fL "$download_url" -o "$INSTALL_PATH/dcr"
+    chmod +x "$INSTALL_PATH/dcr"
+    success "Binary ${asset_name} downloaded (${tag})"
+}
+
+prepare_sources() {
+    log "Fetching sources..."
+    rm -rf "$TMPDIR"
+    git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    if [ "$CHANNEL" = "dev" ]; then
+        git clone --depth 1 --branch dev "$REPO_URL" "$TMPDIR" 2>/dev/null || \
+        git clone --depth 1 "$REPO_URL" "$TMPDIR"
+    fi
+    success "Sources fetched"
+}
+
+build_binary() {
+    log "Building release binary..."
+    (cd "$TMPDIR" && cargo build --release)
+    success "Build completed"
+}
+
+install_built_binary() {
+    mkdir -p "$INSTALL_PATH"
+    cp "$TMPDIR/target/release/dcr" "$INSTALL_PATH/dcr"
+    chmod +x "$INSTALL_PATH/dcr"
+    success "Binary installed from source"
+}
+
+install_link() {
+    log "Creating symlink..."
+    mkdir -p "$BINPATH"
+    ln -sf "$INSTALL_PATH/dcr" "$BINPATH/dcr"
+    success "Command 'dcr' added to $BINPATH"
+}
+
+check_path() {
+    if ! echo "$PATH" | grep -q "$BINPATH"; then
+        warn "Directory $BINPATH not found in PATH"
+        echo "Add this to ~/.bashrc, ~/.zshrc or ~/.profile:"
+        echo "export PATH=\"$BINPATH:\$PATH\""
+    fi
+}
+
+cleanup() {
+    rm -rf "$TMPDIR" 2>/dev/null || true
+}
+
+main() {
+    log "Starting DCR installation for BSD"
+
+    check_os
+    select_channel
+    check_common_dependencies
+    detect_target
+    select_install_mode
+    cleanup
+
+    if [ "$INSTALL_MODE" = "build" ]; then
+        check_build_dependencies
+        prepare_sources
+        build_binary
+        install_built_binary
+    else
+        download_binary
+    fi
+
+    install_link
+    check_path
+    cleanup
+
+    success "Installation completed successfully"
+    log "Log saved to $LOGFILE"
+}
+
+main "$@"

packaging/snap/snapcraft.yaml

@@ -0,0 +1,18 @@
+name: dcrup
+base: core22
+version: '0.6.9'
+summary: Cargo-like utility to manage C/C++ projects
+description: |
+  A build tool and package manager for C/C++ projects inspired by Rust's Cargo.
+
+grade: stable
+confinement: classic
+
+apps:
+  dcr:
+    command: bin/dcr
+
+parts:
+  dcr:
+    plugin: dump
+    source: dist/

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "stable"

scripts/sync-releases-to-gitlab.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Sync all GitHub Releases (with assets) to GitLab Releases."""
+
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+import uuid
+
+GL_TOKEN = os.environ.get("GL_TOKEN")
+if not GL_TOKEN:
+    print("FATAL: GL_TOKEN environment variable not set", file=sys.stderr)
+    sys.exit(1)
+
+GL_PROJECT = "dexoron-studio%2Fdcr"
+GL_PROJECT_RAW = "dexoron-studio/dcr"
+GL_API = "https://gitlab.com/api/v4"
+GH_REPO = "dexoron/dcr"
+
+
+def gl_api(method, path, data=None, filepath=None, retries=5):
+    url = f"{GL_API}/{path}"
+    headers = {"PRIVATE-TOKEN": GL_TOKEN}
+
+    if data is not None and filepath is None:
+        headers["Content-Type"] = "application/json"
+        body = json.dumps(data).encode()
+    elif filepath:
+        boundary = uuid.uuid4().hex
+        with open(filepath, "rb") as f:
+            fdata = f.read()
+        fname = os.path.basename(filepath)
+        parts = []
+        parts.append(f"--{boundary}".encode())
+        parts.append(f'Content-Disposition: form-data; name="file"; filename="{fname}"'.encode())
+        parts.append(b"Content-Type: application/octet-stream")
+        parts.append(b"")
+        parts.append(fdata)
+        parts.append(f"--{boundary}--".encode())
+        parts.append(b"")
+        body = b"\r\n".join(parts)
+        headers["Content-Type"] = f"multipart/form-data; boundary={boundary}"
+    else:
+        body = None
+
+    for attempt in range(retries):
+        try:
+            req = urllib.request.Request(url, data=body, headers=headers, method=method)
+            with urllib.request.urlopen(req) as resp:
+                text = resp.read().decode()
+                return json.loads(text) if text else None
+        except urllib.error.HTTPError as e:
+            body_text = e.read().decode() if e.fp else ""
+            if e.code in (409, 429) and attempt < retries - 1:
+                time.sleep(3)
+                continue
+            if attempt < retries - 1:
+                time.sleep(1)
+                continue
+            print(f"  HTTP {e.code}: {body_text[:300]}", file=sys.stderr)
+            return None
+        except Exception as e:
+            if attempt < retries - 1:
+                time.sleep(1)
+                continue
+            print(f"  Error: {e}", file=sys.stderr)
+            return None
+    return None
+
+
+def download_file(url, dest):
+    with urllib.request.urlopen(url) as resp:
+        with open(dest, "wb") as f:
+            f.write(resp.read())
+
+
+# --- MAIN ---
+print("Fetching GitHub releases...")
+with urllib.request.urlopen(f"https://api.github.com/repos/{GH_REPO}/releases?per_page=50") as r:
+    gh_releases = json.loads(r.read().decode())
+
+print(f"Found {len(gh_releases)} releases on GitHub")
+
+# Reverse to process oldest first (GitHub returns newest first)
+gh_releases.reverse()
+
+print("Fetching existing GitLab releases and their assets...")
+existing = gl_api("GET", f"projects/{GL_PROJECT}/releases?per_page=100") or []
+existing = existing if isinstance(existing, list) else []
+
+# Build map: tag -> set of existing asset names
+gl_assets = {}
+for rel in existing:
+    tag = rel["tag_name"]
+    links = rel.get("assets", {}).get("links", []) or rel.get("assets", {}).get("sources", []) or []
+    gl_assets[tag] = {l.get("name", "") for l in links if isinstance(l, dict)}
+    # Also get the release description to check if it needs updating
+    gl_assets[tag + "__desc"] = rel.get("description", "")
+
+print(f"Existing GitLab releases: {len(existing)}")
+
+download_dir = "/tmp/gh-assets"
+os.makedirs(download_dir, exist_ok=True)
+
+# Reverse: process older first so newer releases with many assets get their description too
+# Actually, process in original order
+total = len(gh_releases)
+for i, rel in enumerate(gh_releases):
+    tag = rel["tag_name"]
+    body = rel.get("body", "") or ""
+    assets = rel.get("assets", [])
+    if isinstance(assets, dict):
+        assets = assets.get("nodes", []) or []
+
+    print(f"\n{'='*60}")
+    print(f"[{i+1}/{total}] {tag} ({len(assets)} assets)")
+
+    # Create or update release
+    existing_tag = tag in gl_assets
+    if not existing_tag:
+        print(f"  Creating release...")
+        result = gl_api("POST", f"projects/{GL_PROJECT}/releases", data={
+            "tag_name": tag,
+            "name": rel.get("name", tag),
+            "description": body,
+            "ref": "master",
+        })
+        if result is None:
+            print(f"  FAILED — skip")
+            continue
+        print(f"  OK")
+    else:
+        # Update description if needed
+        existing_desc = gl_assets.get(tag + "__desc", "")
+        if body and body != existing_desc:
+            print(f"  Updating description...")
+            gl_api("PUT", f"projects/{GL_PROJECT}/releases/{urllib.request.quote(tag, safe='')}",
+                   data={"description": body})
+
+    existing_links = gl_assets.get(tag, set())
+
+    for j, asset in enumerate(assets):
+        aname = asset.get("name", "")
+        aurl = asset.get("browser_download_url", "")
+        if not aurl:
+            continue
+
+        if aname in existing_links:
+            print(f"  [{j+1}/{len(assets)}] {aname} — already exists")
+            continue
+
+        fpath = os.path.join(download_dir, aname)
+        print(f"  [{j+1}/{len(assets)}] {aname}...", end=" ", flush=True)
+
+        # Download from GitHub
+        try:
+            download_file(aurl, fpath)
+        except Exception as e:
+            print(f"download failed: {e}")
+            continue
+
+        # Upload to GitLab
+        up = gl_api("POST", f"projects/{GL_PROJECT}/uploads", filepath=fpath)
+        if not up or "url" not in up:
+            size_mb = os.path.getsize(fpath) / (1024 * 1024)
+            print(f"upload failed ({size_mb:.1f} MB)")
+            os.remove(fpath)
+            continue
+
+        file_url = up["url"]
+        full_url = f"https://gitlab.com/{GL_PROJECT_RAW}{file_url}"
+
+        # Link asset to release
+        encoded_tag = urllib.request.quote(tag, safe='')
+        link = gl_api("POST",
+            f"projects/{GL_PROJECT}/releases/{encoded_tag}/assets/links",
+            data={"name": aname, "url": full_url},
+            retries=5)
+        if link:
+            print(f"linked")
+            existing_links.add(aname)
+        else:
+            print(f"link failed")
+
+        os.remove(fpath)
+
+    time.sleep(0.3)
+
+print(f"\n{'='*60}")
+print("Done!")

src/cli/add.rs

@@ -0,0 +1,253 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::config::Config;
+use crate::core::deps::register;
+use crate::utils::fs::find_project_root;
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_GREEN, colored};
+use toml::Value;
+use toml::map::Map;
+
+pub struct AddArgs {
+    pub name: String,
+    pub path: Option<String>,
+    pub git: Option<String>,
+    pub branch: Option<String>,
+    pub tag: Option<String>,
+    pub rev: Option<String>,
+    pub version_from_registry: Option<String>,
+}
+
+pub fn add(args: &[String]) -> i32 {
+    let add_args = match parse_add_args(args) {
+        Ok(a) => a,
+        Err(code) => return code,
+    };
+
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
+            error("dcr.toml file not found");
+            return 1;
+        }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+
+    let mut config = match Config::open(&root.join("dcr.toml").to_string_lossy()) {
+        Ok(cfg) => cfg,
+        Err(err) => {
+            error(&err.to_string());
+            return 1;
+        }
+    };
+
+    let dep_value = if let Some(git_url) = add_args.git {
+        if add_args.branch.is_none() && add_args.tag.is_none() && add_args.rev.is_none() {
+            let mut table = Map::new();
+            table.insert("git".to_string(), Value::String(git_url));
+            Value::Table(table)
+        } else {
+            let mut table = Map::new();
+            table.insert("git".to_string(), Value::String(git_url));
+            if let Some(b) = add_args.branch {
+                table.insert("branch".to_string(), Value::String(b));
+            }
+            if let Some(t) = add_args.tag {
+                table.insert("tag".to_string(), Value::String(t));
+            }
+            if let Some(r) = add_args.rev {
+                table.insert("rev".to_string(), Value::String(r));
+            }
+            Value::Table(table)
+        }
+    } else if let Some(path) = add_args.path {
+        let mut table = Map::new();
+        table.insert("path".to_string(), Value::String(path));
+        Value::Table(table)
+    } else if let Some(version) = add_args.version_from_registry {
+        Value::String(version)
+    } else {
+        error("Dependency source (path or git) must be provided");
+        return 1;
+    };
+
+    let key = format!("dependencies.{}", add_args.name);
+    if let Err(err) = config.edit(&key, dep_value) {
+        error(&format!("Failed to update dcr.toml: {}", err));
+        return 1;
+    }
+
+    println!(
+        "    {} dependency `{}` to dcr.toml",
+        colored("Added", BOLD_GREEN),
+        add_args.name
+    );
+    0
+}
+
+fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
+    if args.is_empty() {
+        error("Usage: dcr add <name> <source> [--branch <branch> | --tag <tag> | --rev <rev>]");
+        error("Sources:");
+        error("  user/repo                 -> github.com/user/repo");
+        error("  github:user/repo          -> github.com/user/repo");
+        error("  gitlab:user/repo          -> gitlab.com/user/repo");
+        error("  git:host.com/user/repo    -> host.com/user/repo");
+        error("  path:./path/to/lib        -> local path");
+        return Err(1);
+    }
+
+    let mut name = String::new();
+    let source_spec: String;
+    let mut branch = None;
+    let mut tag = None;
+    let mut rev = None;
+
+    let mut iter = args.iter();
+    if let Some(n) = iter.next() {
+        if n.starts_with("--") {
+            error("First argument must be the dependency name");
+            return Err(1);
+        }
+        name = n.clone();
+    }
+
+    if let Some(s) = iter.next() {
+        if s.starts_with("--") {
+            error("Second argument must be the dependency source");
+            return Err(1);
+        }
+        source_spec = s.clone();
+    } else {
+        // No source provided — try registry auto-lookup
+        match register::resolve_package_from_registry(&name) {
+            Ok(info) => {
+                let version = info
+                    .get("latest_version")
+                    .or_else(|| info.get("version"))
+                    .and_then(|v| v.as_str())
+                    .ok_or_else(|| {
+                        (
+                            "Registry entry for `".to_string() + &name + "` has no version field",
+                            1,
+                        )
+                    })
+                    .map_err(|(msg, code)| {
+                        error(&msg);
+                        code
+                    })?;
+                return Ok(AddArgs {
+                    name,
+                    path: None,
+                    git: None,
+                    branch: None,
+                    tag: None,
+                    rev: None,
+                    version_from_registry: Some(version.to_string()),
+                });
+            }
+            Err(e) => {
+                error(&format!("Cannot add `{}` without source: {}", name, e));
+                return Err(1);
+            }
+        }
+    }
+
+    while let Some(arg) = iter.next() {
+        match arg.as_str() {
+            "--branch" => {
+                branch = iter.next().cloned();
+                if branch.is_none() {
+                    error("--branch requires a value");
+                    return Err(1);
+                }
+            }
+            "--tag" => {
+                tag = iter.next().cloned();
+                if tag.is_none() {
+                    error("--tag requires a value");
+                    return Err(1);
+                }
+            }
+            "--rev" => {
+                rev = iter.next().cloned();
+                if rev.is_none() {
+                    error("--rev requires a value");
+                    return Err(1);
+                }
+            }
+            _ => {
+                error(&format!("Unknown argument: {}", arg));
+                return Err(1);
+            }
+        }
+    }
+
+    let mut path = None;
+    let mut git = None;
+
+    if let Some(p) = source_spec.strip_prefix("path:") {
+        path = Some(p.to_string());
+    } else if let Some(g) = source_spec.strip_prefix("github:") {
+        git = Some(format!("https://github.com/{}", g));
+    } else if let Some(g) = source_spec.strip_prefix("gitlab:") {
+        git = Some(format!("https://gitlab.com/{}", g));
+    } else if let Some(g) = source_spec.strip_prefix("git:") {
+        if g.contains('/') && !g.contains('.') {
+            // git:user/repo -> default to github
+            git = Some(format!("https://github.com/{}", g));
+        } else {
+            // git:host.com/user/repo
+            let url = if g.starts_with("http") || g.starts_with("git@") {
+                g.to_string()
+            } else {
+                format!("https://{}", g)
+            };
+            git = Some(url);
+        }
+    } else if source_spec.starts_with("http://")
+        || source_spec.starts_with("https://")
+        || source_spec.starts_with("git@")
+    {
+        git = Some(source_spec);
+    } else {
+        error("Source must have a prefix (path:, git:, github:, gitlab:) or be a full URL");
+        return Err(1);
+    }
+
+    Ok(AddArgs {
+        name,
+        path,
+        git,
+        branch,
+        tag,
+        rev,
+        version_from_registry: None,
+    })
+}

src/cli/clean.rs

@@ -1,9 +1,28 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::config::flags;
 use crate::core::config::Config;
 use crate::core::workspace::parse_workspace;
-use crate::utils::fs::{check_dir, find_project_root};
+use crate::utils::build::parse_version_info;
+use crate::utils::fs::{check_dir, find_project_root, with_dir};
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_GREEN, colored};
+use glob::glob;
 use std::fs;
 use std::path::Path;
 
@@ -45,17 +64,28 @@ pub fn clean(args: &[String]) -> i32 {
 
 struct CleanFlags {
     profile: Option<String>,
+    target: Option<String>,
     all: bool,
 }
 
 fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
     let mut profile: Option<String> = None;
+    let mut target: Option<String> = None;
     let mut all = false;
-    for arg in args {
+    let mut iter = args.iter();
+    while let Some(arg) = iter.next() {
         if arg == "--all" {
             all = true;
             continue;
         }
+        if arg == "--target" {
+            if let Some(t) = iter.next() {
+                target = Some(t.clone());
+            } else {
+                return Err("--target requires a value".to_string());
+            }
+            continue;
+        }
         if arg.starts_with("--") {
             let candidate = arg.trim_start_matches("--").to_string();
             if flags(&candidate).is_some() {
@@ -68,23 +98,71 @@ fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
         }
         return Err("Unknown argument".to_string());
     }
-    Ok(CleanFlags { profile, all })
+    Ok(CleanFlags {
+        profile,
+        target,
+        all,
+    })
 }
 
 fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
     let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+
+    let target = flags
+        .target
+        .clone()
+        .or_else(|| {
+            config
+                .get("build.target")
+                .and_then(|v| v.as_str())
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+        })
+        .or_else(|| {
+            Some(if cfg!(target_os = "linux") {
+                format!("{}-unknown-linux-gnu", std::env::consts::ARCH)
+            } else if cfg!(target_os = "macos") {
+                "x86_64-apple-darwin".to_string()
+            } else if cfg!(target_os = "windows") {
+                "x86_64-pc-windows-msvc".to_string()
+            } else if cfg!(any(
+                target_os = "freebsd",
+                target_os = "openbsd",
+                target_os = "netbsd",
+                target_os = "dragonfly"
+            )) {
+                format!(
+                    "{}-unknown-{}",
+                    std::env::consts::ARCH,
+                    std::env::consts::OS
+                )
+            } else {
+                "unknown".to_string()
+            })
+        });
+
     if flags.all
-        && let Some(workspace) = parse_workspace(&config, root)?
+        && let Some(workspace) = parse_workspace(
+            &config,
+            flags.profile.as_deref().unwrap_or("debug"),
+            target.as_deref(),
+            root,
+        )?
     {
         for member in &workspace.members {
-            clean_project_at(&member.path, flags.profile.as_deref())?;
+            clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?;
         }
     }
-    clean_project_at(root, flags.profile.as_deref())
+    clean_project_at(root, flags.profile.as_deref(), target.as_deref())
 }
 
-fn clean_project_at(project_root: &Path, profile: Option<&str>) -> Result<(), String> {
+fn clean_project_at(
+    project_root: &Path,
+    profile: Option<&str>,
+    target: Option<&str>,
+) -> Result<(), String> {
     with_dir(project_root, || {
+        let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
         let project_name = std::env::current_dir()
             .ok()
             .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
@@ -97,42 +175,93 @@ fn clean_project_at(project_root: &Path, profile: Option<&str>) -> Result<(), St
             "    Cleaning project `{}`",
             colored(&project_name, BOLD_GREEN)
         );
-        if !items.contains(&"target".to_string()) {
-            warn("Directory target not found");
-            return Ok(());
-        }
-
         if let Some(profile) = profile {
+            let target_dir = if let Some(t) = target {
+                format!("target/{t}/{profile}")
+            } else {
+                format!("target/{profile}")
+            };
             let target_items = check_dir(Some("target")).unwrap_or_default();
-            if !target_items.contains(&profile.to_string()) {
+            let parent_dir = target.unwrap_or("");
-                warn(&format!("Directory target/{profile} not found"));
+            let dir_exists = if target.is_some() {
-                return Ok(());
+                target_items.contains(&parent_dir.to_string())
-            }
+            } else {
+                target_items.contains(&profile.to_string())
+            };
+            if !dir_exists {
+                warn(&format!("Directory target/{} not found", target_dir));
+            } else {
                 println!("    Profile: {}", colored(profile, BOLD_GREEN));
-            let _ = fs::remove_dir_all(format!("target/{profile}"));
+                if let Some(t) = target {
+                    println!("    Target: {}", colored(t, BOLD_GREEN));
+                }
+                let _ = fs::remove_dir_all(&target_dir);
                 println!(
-                "{} Removed directory target/{profile}",
+                    "{} Removed directory {}",
-                colored("\n    ✔", BOLD_GREEN)
+                    colored("\n    ✔", BOLD_GREEN),
+                    target_dir
                 );
+            }
+            clean_custom_paths(&config, profile)?;
             return Ok(());
         }
 
+        if items.contains(&"target".to_string()) {
             let _ = fs::remove_dir_all("target");
             println!(
                 "{} Removed directory target",
                 colored("\n    ✔", BOLD_GREEN)
             );
+        } else {
+            warn("Directory target not found");
+        }
+        clean_custom_paths(&config, "debug")?;
+        clean_custom_paths(&config, "release")?;
         Ok(())
     })
 }
 
-fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
+fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
-where
+    let patterns = match config.get("build.clean") {
-    F: FnOnce() -> Result<T, String>,
+        Some(v) => v
-{
+            .as_array()
-    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
+            .ok_or_else(|| "build.clean must be an array of strings".to_string())?
-    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
+            .iter()
-    let result = f();
+            .filter_map(|item| item.as_str())
-    let _ = std::env::set_current_dir(prev);
+            .map(|s| {
-    result
+                let value = s.replace("{profile}", profile);
+                substitute_version_vars(&value, config)
+            })
+            .collect::<Vec<String>>(),
+        None => Vec::new(),
+    };
+    if patterns.is_empty() {
+        return Ok(());
+    }
+    for pattern in patterns {
+        for entry in glob(&pattern).map_err(|err| format!("glob error: {err}"))? {
+            let path = entry.map_err(|err| format!("glob error: {err}"))?;
+            if path.is_dir() {
+                let _ = fs::remove_dir_all(&path);
+            } else if path.is_file() {
+                let _ = fs::remove_file(&path);
+            }
+        }
+    }
+    Ok(())
+}
+
+fn substitute_version_vars(value: &str, config: &Config) -> String {
+    let version = config
+        .get("package.version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    let info = parse_version_info(version);
+    value
+        .replace("{version}", &info.full)
+        .replace("{version_major}", &info.major)
+        .replace("{version_minor}", &info.minor)
+        .replace("{version_patch}", &info.patch)
+        .replace("{version_suffix}", &info.suffix)
+        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

src/cli/flag_update.rs

@@ -1,8 +1,26 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::utils::log::{error, warn};
 use reqwest::blocking::Client;
 use serde::Deserialize;
 use std::fs;
 use std::path::{Path, PathBuf};
+#[cfg(target_os = "linux")]
 use std::process::Command;
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -137,8 +155,8 @@ fn download_asset(client: &Client, url: &str) -> Result<Vec<u8>, String> {
 fn asset_candidates(target: &str) -> Vec<String> {
     let mut names = vec![format!("dcr-{target}")];
 
-    if target == "x86_64-pc-windows-msvc" {
+    if target.contains("-windows-") || target.ends_with("-windows") {
-        names.push("dcr-x86_64-pc-windows-msvc.exe".to_string());
+        names.push(format!("dcr-{target}.exe"));
     }
 
     names
@@ -156,14 +174,14 @@ fn temp_binary_path(current_exe: &Path) -> PathBuf {
     current_exe.with_extension(extension)
 }
 
-fn set_executable_permissions(path: &Path) {
+fn set_executable_permissions(_path: &Path) {
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
-        if let Ok(meta) = fs::metadata(path) {
+        if let Ok(meta) = fs::metadata(_path) {
             let mut perms = meta.permissions();
             perms.set_mode(0o755);
-            let _ = fs::set_permissions(path, perms);
+            let _ = fs::set_permissions(_path, perms);
         }
     }
 }

src/cli/flags.rs

@@ -0,0 +1,95 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::config::{PROFILE, flags};
+use crate::utils::log::warn;
+
+pub struct BuildRunFlags {
+    pub profile: String,
+    pub target: Option<String>,
+    pub workspace: Option<String>,
+    pub force: bool,
+    pub clean: bool,
+    pub verbose: bool,
+}
+
+pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
+    let mut profile = PROFILE.to_string();
+    let mut target = None;
+    let mut workspace = None;
+    let mut force = false;
+    let mut clean = false;
+    let mut verbose = false;
+    let mut iter = args.iter();
+
+    while let Some(arg) = iter.next() {
+        if !arg.starts_with("--") {
+            warn("Unknown argument");
+            return Err(1);
+        }
+        let candidate = arg.trim_start_matches("--");
+        if candidate == "force" {
+            force = true;
+            continue;
+        }
+        if candidate == "clean" {
+            clean = true;
+            continue;
+        }
+        if candidate == "verbose" {
+            verbose = true;
+            continue;
+        }
+        if candidate == "workspace" {
+            if let Some(w) = iter.next() {
+                workspace = Some(w.clone());
+            } else {
+                warn("--workspace requires a value");
+                return Err(1);
+            }
+            continue;
+        }
+        if candidate == "target" {
+            if let Some(t) = iter.next() {
+                target = Some(t.clone());
+            } else {
+                warn("--target requires a value");
+                return Err(1);
+            }
+            continue;
+        }
+        if flags(candidate).is_some() {
+            if profile != PROFILE {
+                warn("Duplicate profile flag");
+                return Err(1);
+            }
+            profile = candidate.to_string();
+            continue;
+        }
+        warn("Unknown build flag");
+        return Err(1);
+    }
+
+    Ok(BuildRunFlags {
+        profile,
+        target,
+        workspace,
+        force,
+        clean,
+        verbose,
+    })
+}

src/cli/fmt.rs

@@ -0,0 +1,81 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_GREEN, colored};
+use glob::glob;
+use std::process::Command;
+
+pub fn fmt(_args: &[String]) -> i32 {
+    let patterns = [
+        "src/**/*.c",
+        "src/**/*.cpp",
+        "src/**/*.cxx",
+        "src/**/*.cc",
+        "src/**/*.h",
+        "src/**/*.hpp",
+        "src/**/*.hxx",
+        "src/**/*.hh",
+        "tests/**/*.c",
+        "tests/**/*.cpp",
+        "tests/**/*.cxx",
+        "tests/**/*.cc",
+        "tests/**/*.h",
+        "tests/**/*.hpp",
+        "tests/**/*.hxx",
+        "tests/**/*.hh",
+    ];
+
+    let mut files = Vec::new();
+    for pattern in patterns {
+        if let Ok(paths) = glob(pattern) {
+            for path in paths.flatten() {
+                if let Some(s) = path.to_str() {
+                    files.push(s.to_string());
+                }
+            }
+        }
+    }
+
+    if files.is_empty() {
+        println!("    {} No files to format", colored("Format", BOLD_GREEN));
+        return 0;
+    }
+
+    println!(
+        "    {} {} files",
+        colored("Formatting", BOLD_GREEN),
+        files.len()
+    );
+
+    let status = Command::new("clang-format").arg("-i").args(&files).status();
+
+    match status {
+        Ok(s) if s.success() => {
+            println!("    {} successful", colored("Format", BOLD_GREEN));
+            0
+        }
+        Ok(s) => {
+            error(&format!("clang-format failed with status: {}", s));
+            1
+        }
+        Err(e) => {
+            error(&format!("Failed to execute clang-format: {}", e));
+            1
+        }
+    }
+}

src/cli/help.rs

@@ -1,3 +1,20 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 
 pub fn help() -> i32 {
@@ -12,15 +29,22 @@ pub fn help() -> i32 {
     println!("    init              Initialize the current directory as a project");
     println!("    build [--profile] Build the project (default: --debug)");
     println!("    run [--profile]   Build and run the project (default: --debug)");
+    println!("    tree              Display the dependency tree");
+    println!("    test              Run project tests (alias: tests)");
+    println!("    fmt               Format all C/C++ source files using clang-format");
     println!("    clean             Remove the target directory");
+    println!("    gen <subcommand>  Generate IDE integration files");
     printc("FLAGS:", BOLD_GREEN);
     println!("    --help            Show command help");
     println!("    --update          Update dcr to the latest version");
     println!("    --version         Show dcr version");
     println!();
     printc("OPTIONS:", BOLD_GREEN);
-    println!("    --debug           Build with debug profile");
+    println!("    --debug           Use debug profile");
-    println!("    --release         Build with release profile");
+    println!("    --release         Use release profile");
+    println!("    --force           Force rebuild (build/run)");
+    println!("    --clean           Clean before build (build/run)");
+    println!("    --all             Clean all workspace members (clean)");
     println!();
     printc("EXAMPLES:", BOLD_GREEN);
     printc("    dcr new hello", BOLD_CYAN);

src/cli/init.rs

@@ -1,5 +1,22 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::config::FILE_MAIN_C;
-use crate::core::config::Config;
+use crate::core::config::{validate_package_name, Config};
 use crate::utils::fs::check_dir;
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
@@ -24,6 +41,15 @@ pub fn init(args: &[String]) -> i32 {
         return 1;
     }
 
+    if let Err(e) = validate_package_name(&project_name) {
+        error(&format!(
+            "Invalid project name `{}`: {}",
+            colored(&project_name, BOLD_CYAN),
+            e
+        ));
+        return 1;
+    }
+
     let cwd = std::env::current_dir()
         .map(|v| v.to_string_lossy().to_string())
         .unwrap_or_else(|_| ".".to_string());
@@ -65,7 +91,7 @@ pub fn init(args: &[String]) -> i32 {
         return 1;
     }
     println!(
-        "    {} Created file {}\n",
+        "    {} Created file {}",
         colored("✔", BOLD_GREEN),
         colored("src/main.c", BOLD_CYAN)
     );

src/cli/mod.rs

@@ -1,7 +1,31 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pub mod add;
 pub mod build;
 pub mod clean;
 pub mod flag_update;
+pub mod flags;
+pub mod fmt;
+pub mod r#gen;
 pub mod help;
 pub mod init;
 pub mod new;
 pub mod run;
+pub mod setup;
+pub mod test;
+pub mod tree;

src/cli/new.rs

@@ -1,5 +1,22 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::config::FILE_MAIN_C;
-use crate::core::config::Config;
+use crate::core::config::{validate_package_name, Config};
 use crate::utils::fs::check_dir;
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
@@ -25,6 +42,15 @@ pub fn new(args: &[String]) -> i32 {
         colored(project_name, BOLD_CYAN)
     );
 
+    if let Err(e) = validate_package_name(project_name) {
+        error(&format!(
+            "Invalid project name `{}`: {}",
+            colored(project_name, BOLD_CYAN),
+            e
+        ));
+        return 1;
+    }
+
     if items.contains(project_name) {
         error(&format!(
             "Directory `{}` already exists\n",
@@ -86,7 +112,7 @@ pub fn new(args: &[String]) -> i32 {
         return 1;
     }
     println!(
-        "    {} Created file {}\n",
+        "    {} Created file {}",
         colored("✔", BOLD_GREEN),
         colored("src/main.c", BOLD_CYAN)
     );

src/cli/run.rs

@@ -1,15 +1,61 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::cli::build::build;
-use crate::config::{PROFILE, flags};
+use crate::cli::flags::parse_build_run_flags;
 use crate::core::config::Config;
 use crate::core::runner::run_binary;
+use crate::utils::build::{normalize_target_os, parse_version_info};
 use crate::utils::fs::find_project_root;
-use crate::utils::log::{error, warn};
+use crate::utils::fs::with_dir;
+use crate::utils::log::error;
 use crate::utils::text::{BOLD_GREEN, colored};
 use std::path::Path;
+use std::process::Command;
+
+fn get_run_cmd(
+    config: &Config,
+    profile: &str,
+    target: Option<&str>,
+    version: &str,
+) -> Option<String> {
+    let base = config.get("run.cmd").and_then(|v| v.as_str());
+    let target_cmd = if let Some(t) = target {
+        let normalized_t = normalize_target_os(t);
+        config
+            .get(&format!("run.{}.cmd", normalized_t))
+            .or_else(|| config.get(&format!("run.{}.cmd", t)))
+            .and_then(|v| v.as_str())
+    } else {
+        None
+    };
+    let profile_cmd = config
+        .get(&format!("run.{}.cmd", profile))
+        .and_then(|v| v.as_str());
+    let cmd = target_cmd.or(profile_cmd).or(base)?;
+    let trimmed = cmd.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(substitute_run_vars(trimmed, profile, version))
+    }
+}
 
 pub fn run(args: &[String]) -> i32 {
-    let mut active_profile = PROFILE.to_string();
-
     let start_dir = match std::env::current_dir() {
         Ok(dir) => dir,
         Err(_) => {
@@ -37,64 +83,213 @@ pub fn run(args: &[String]) -> i32 {
             return 1;
         }
     };
+    let flags = match parse_build_run_flags(args) {
+        Ok(v) => v,
+        Err(_) => return 1,
+    };
+
+    // Handle workspace-only root: delegate to workspace member
+    if config.is_workspace_only() {
+        let ws = match crate::core::workspace::parse_workspace(
+            &config,
+            &flags.profile,
+            flags.target.as_deref(),
+            &root,
+        ) {
+            Ok(Some(ws)) => ws,
+            Ok(None) => {
+                error("Workspace root has no members defined");
+                return 1;
+            }
+            Err(e) => {
+                error(&e);
+                return 1;
+            }
+        };
+        let member = match &flags.workspace {
+            Some(name) => ws.members.iter().find(|m| m.name == *name),
+            None => ws.main_member(),
+        };
+        let member = match member {
+            Some(m) => m,
+            None => {
+                if let Some(name) = &flags.workspace {
+                    error(&format!("Workspace member '{name}' not found"));
+                } else {
+                    error("No workspace member to run (set `main = true` on one member)");
+                }
+                return 1;
+            }
+        };
+        // Build and run from the member's directory
+        return match with_dir(&member.path, || {
+            run_project(&member.path, &flags, Some(root.as_path()))
+        }) {
+            Ok(code) => code,
+            Err(e) => {
+                error(&e);
+                1
+            }
+        };
+    }
+
+    match run_project(&root, &flags, None) {
+        Ok(code) => code,
+        Err(e) => {
+            error(&e);
+            1
+        }
+    }
+}
+
+fn run_project(
+    root: &Path,
+    flags: &crate::cli::flags::BuildRunFlags,
+    workspace_root: Option<&Path>,
+) -> Result<i32, String> {
+    let config =
+        Config::open(root.join("dcr.toml").to_str().unwrap()).map_err(|err| err.to_string())?;
+
     let project_name: &str = config
         .get("package.name")
         .and_then(|v| v.as_str())
         .unwrap_or("");
+
+    // If no target specified, use default host target for target-specific config
+    let mut target = flags.target.clone();
+    if target.is_none() {
+        let default_target = if cfg!(target_os = "linux") {
+            format!("{}-unknown-linux-gnu", std::env::consts::ARCH)
+        } else if cfg!(target_os = "macos") {
+            "x86_64-apple-darwin".to_string()
+        } else if cfg!(target_os = "windows") {
+            "x86_64-pc-windows-msvc".to_string()
+        } else if cfg!(any(
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "dragonfly"
+        )) {
+            format!(
+                "{}-unknown-{}",
+                std::env::consts::ARCH,
+                std::env::consts::OS
+            )
+        } else {
+            "unknown".to_string()
+        };
+        target = Some(default_target);
+    }
+
     let build_kind = config
-        .get("build.kind")
+        .get(&format!("build.{}.kind", flags.profile))
+        .and_then(|v| v.as_str())
+        .or_else(|| config.get("build.kind").and_then(|v| v.as_str()))
+        .unwrap_or("");
+
+    let out_dir =
+        crate::cli::build::get_build_string_with_profile(&config, "out_dir", &flags.profile);
+    let normalized_target_dir = if !out_dir.is_empty() {
+        Some(out_dir)
+    } else {
+        match workspace_root {
+            Some(wr) => target
+                .as_ref()
+                .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile))
+                .map(|rel| wr.join(&rel).to_string_lossy().to_string()),
+            None => target
+                .as_ref()
+                .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile)),
+        }
+    };
+
+    let version = config
+        .get("package.version")
         .and_then(|v| v.as_str())
         .unwrap_or("");
-    let target_dir = config
+    let run_cmd = get_run_cmd(&config, &flags.profile, target.as_deref(), version);
-        .get("build.target")
-        .and_then(|v| v.as_str())
-        .map(|s| s.trim())
-        .filter(|s| !s.is_empty());
-
-    if let Some(first_arg) = args.first() {
-        if first_arg.starts_with("--") {
-            let candidate = first_arg.trim_start_matches("--");
-            if flags(candidate).is_some() {
-                active_profile = candidate.to_string();
-            } else {
-                warn("Unknown build flag");
-                return 1;
-            }
-        } else {
-            warn("Unknown argument");
-            return 1;
-        }
-    }
 
     let kind = build_kind.trim();
-    if kind == "staticlib" || kind == "sharedlib" {
+    if run_cmd.is_none()
-        error("Cannot run library build");
+        && (kind == "staticlib" || kind == "sharedlib" || kind == "efi" || kind == "elf")
-        return 1;
+    {
+        return Err("Cannot run library build".to_string());
     }
-    let build_status = build(args);
+
-    let bin_path = crate::platform::bin_path(&active_profile, project_name, target_dir);
+    let build_status = build(&args_for_build(flags));
+    let bin_path = crate::platform::bin_path(
+        &flags.profile,
+        project_name,
+        normalized_target_dir.as_deref(),
+    );
     if build_status == 0 {
+        if let Some(cmd) = run_cmd {
+            println!("\n    {} {}", colored("Running", BOLD_GREEN), cmd);
+            println!("--------------------------------");
+            return Ok(run_shell(&cmd));
+        }
         println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
         println!("--------------------------------");
-        return run_binary(project_name, &active_profile, target_dir);
+        return Ok(run_binary(
+            project_name,
+            &flags.profile,
+            normalized_target_dir.as_deref(),
+        ));
     }
 
-    let fallback_code = run_binary(project_name, &active_profile, target_dir);
+    let fallback_code = if let Some(cmd) = run_cmd {
+        run_shell(&cmd)
+    } else {
+        run_binary(
+            project_name,
+            &flags.profile,
+            normalized_target_dir.as_deref(),
+        )
+    };
     if fallback_code != 1 {
-        return fallback_code;
+        return Ok(fallback_code);
     }
 
-    error("Fix errors in the code to run the project");
+    Err("Fix errors in the code to run the project".to_string())
-    1
 }
 
-fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
+fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> Vec<String> {
-where
+    let mut args = Vec::new();
-    F: FnOnce() -> Result<T, String>,
+    args.push(format!("--{}", flags.profile));
-{
+    if let Some(ref target) = flags.target {
-    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
+        args.push("--target".to_string());
-    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
+        args.push(target.clone());
-    let result = f();
+    }
-    let _ = std::env::set_current_dir(prev);
+    if let Some(ref name) = flags.workspace {
-    result
+        args.push("--workspace".to_string());
+        args.push(name.clone());
+    }
+    if flags.verbose {
+        args.push("--verbose".to_string());
+    }
+    args
+}
+
+fn run_shell(cmd: &str) -> i32 {
+    let status = if cfg!(target_os = "windows") {
+        Command::new("cmd").arg("/C").arg(cmd).status()
+    } else {
+        Command::new("sh").arg("-c").arg(cmd).status()
+    };
+    match status {
+        Ok(s) if s.success() => 0,
+        Ok(s) => s.code().unwrap_or(1),
+        Err(_) => 1,
+    }
+}
+
+fn substitute_run_vars(cmd: &str, profile: &str, version: &str) -> String {
+    let info = parse_version_info(version);
+    cmd.replace("{profile}", profile)
+        .replace("{version}", &info.full)
+        .replace("{version_major}", &info.major)
+        .replace("{version_minor}", &info.minor)
+        .replace("{version_patch}", &info.patch)
+        .replace("{version_suffix}", &info.suffix)
+        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

src/cli/setup.rs

@@ -0,0 +1,33 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pub fn setup(_args: &[String]) -> i32 {
+    println!("Setting up DCR registries...");
+    match crate::core::registry::RegistryManager::load() {
+        Ok(manager) => {
+            println!("Loaded {} registries.", manager.config.registry.len());
+            for (name, reg) in manager.config.registry {
+                println!("- {}: {} (priority {})", name, reg.url, reg.priority);
+            }
+            0
+        }
+        Err(e) => {
+            println!("Error: {}", e);
+            1
+        }
+    }
+}

src/cli/test.rs

@@ -0,0 +1,388 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::cli::build;
+use crate::config::{FILE_DCR_TEST_H, FILE_TEST_C, flags};
+use crate::core::config::Config;
+use crate::utils::build::{
+    get_config_opt, get_config_str, get_language_with_profile, get_list_with_profile,
+    get_string_with_profile, resolve_compiler, resolve_pkg_config_flags,
+};
+use crate::utils::fs::{find_project_root, with_dir};
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_GREEN, BOLD_RED, RESET, colored};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+const BOLD_BLUE: &str = "\x1b[1m\x1b[94m";
+
+pub fn test(args: &[String]) -> i32 {
+    let mut init_header = false;
+    let mut profile = "debug";
+    for arg in args {
+        if arg == "--help" {
+            println!("USAGE:");
+            println!("    dcr test [--init] [--debug | --release]");
+            println!();
+            println!("ALIASES:");
+            println!("    dcr tests");
+            println!();
+            println!("DESCRIPTION:");
+            println!("    Runs project tests and prints a unified testsuite report.");
+            println!();
+            println!("OPTIONS:");
+            println!("    --init            Create tests/dcr_test.h in current project");
+            println!("    --debug           Build and run tests with debug profile (default)");
+            println!("    --release         Build and run tests with release profile");
+            return 0;
+        }
+        if arg == "--init" {
+            init_header = true;
+            continue;
+        }
+        if arg == "--debug" || arg == "--release" {
+            profile = arg.trim_start_matches("--");
+            continue;
+        }
+        error("Unknown argument");
+        return 1;
+    }
+
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
+            error("dcr.toml file not found");
+            return 1;
+        }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+
+    if init_header {
+        match with_dir(&root, ensure_test_header) {
+            Ok(()) => {}
+            Err(msg) => {
+                error(&msg);
+                return 1;
+            }
+        }
+    }
+
+    match with_dir(&root, || run_testsuite(profile)) {
+        Ok(code) => code,
+        Err(msg) => {
+            error(&msg);
+            1
+        }
+    }
+}
+
+fn run_testsuite(profile: &str) -> Result<i32, String> {
+    if build::build(&[format!("--{profile}")]) != 0 {
+        return Ok(1);
+    }
+
+    let config = Config::open("./dcr.toml").map_err(|_| "Failed to read dcr.toml".to_string())?;
+    let name = get_config_str(&config, "package.name");
+    let language = get_language_with_profile(&config, profile)?;
+    let compiler_cfg = get_string_with_profile(&config, "compiler", profile);
+    let standard = get_string_with_profile(&config, "standard", profile);
+    let package_type = get_config_str(&config, "package.type");
+    let build_kind = get_string_with_profile(&config, "kind", profile);
+    let tc_cc = get_config_opt(&config, "toolchain.cc");
+    let tc_cxx = get_config_opt(&config, "toolchain.cxx");
+    let tc_as = get_config_opt(&config, "toolchain.as");
+    let compiler = resolve_compiler(
+        &language,
+        &compiler_cfg,
+        tc_cc.as_deref(),
+        tc_cxx.as_deref(),
+        tc_as.as_deref(),
+    );
+
+    let mut cflags: Vec<String> = flags(profile)
+        .unwrap_or(&[])
+        .iter()
+        .map(|v| v.to_string())
+        .collect();
+    cflags.extend(get_list_with_profile(&config, "cflags", profile));
+    let ldflags = get_list_with_profile(&config, "ldflags", profile);
+    let pkg_configs = get_list_with_profile(&config, "pkg_config", profile);
+    let (cflags, ldflags) = resolve_pkg_config_flags(&pkg_configs, &cflags, &ldflags)?;
+    let includes = test_include_dirs(&config, profile);
+    let test_sources = collect_test_sources()?;
+    if test_sources.is_empty() {
+        return Err("tests/test.c not found; run 'dcr test --init' first".to_string());
+    }
+
+    let link_project_lib =
+        package_type == "lib" || build_kind == "staticlib" || build_kind == "sharedlib";
+    let mut stdout = String::new();
+    let mut declared = Vec::new();
+    let mut suite_success = true;
+
+    fs::create_dir_all("./tests/target")
+        .map_err(|e| format!("Failed to create tests/target: {e}"))?;
+    for source in &test_sources {
+        declared.extend(extract_test_names_path(source));
+        let stem = source
+            .file_stem()
+            .and_then(|v| v.to_str())
+            .unwrap_or("test");
+        let obj_path = Path::new("./tests/target").join(format!("{stem}.o"));
+        let bin_path =
+            Path::new("./tests/target").join(format!("{stem}{}", std::env::consts::EXE_SUFFIX));
+
+        compile_test_source(&compiler, &standard, &cflags, &includes, source, &obj_path)?;
+        link_test_binary(
+            &compiler,
+            &ldflags,
+            link_project_lib.then_some(name.as_str()),
+            &obj_path,
+            &bin_path,
+        )?;
+
+        let out = Command::new(&bin_path)
+            .output()
+            .map_err(|_| format!("Failed to run `{}`", bin_path.display()))?;
+        stdout.push_str(&String::from_utf8_lossy(&out.stdout));
+        let stderr = String::from_utf8_lossy(&out.stderr);
+        if !stderr.trim().is_empty() {
+            eprint!("{}", stderr);
+        }
+        if !out.status.success() {
+            suite_success = false;
+        }
+    }
+
+    let mut pass = 0;
+    let mut skip = 0;
+    let mut fail = 0;
+    let mut parsed_any = false;
+
+    for line in stdout.lines() {
+        let line = line.trim();
+        if let Some(name) = line.strip_prefix("[PASS] ") {
+            println!("{} {}", colored("[PASS]", BOLD_GREEN), name);
+            pass += 1;
+            parsed_any = true;
+            continue;
+        }
+        if let Some(name) = line.strip_prefix("[SKIP] ") {
+            println!("{} {}", colored("[SKIP]", BOLD_BLUE), name);
+            skip += 1;
+            parsed_any = true;
+            continue;
+        }
+        if let Some(name) = line.strip_prefix("[FAIL] ") {
+            println!("{} {}", colored("[FAIL]", BOLD_RED), name);
+            fail += 1;
+            parsed_any = true;
+            continue;
+        }
+        if let Some((status, name)) = line.split_once('\t') {
+            match status {
+                "PASS" => {
+                    println!("{} {}", colored("[PASS]", BOLD_GREEN), name);
+                    pass += 1;
+                    parsed_any = true;
+                }
+                "SKIP" => {
+                    println!("{} {}", colored("[SKIP]", BOLD_BLUE), name);
+                    skip += 1;
+                    parsed_any = true;
+                }
+                "FAIL" => {
+                    println!("{} {}", colored("[FAIL]", BOLD_RED), name);
+                    fail += 1;
+                    parsed_any = true;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    if !parsed_any {
+        if suite_success {
+            for name in &declared {
+                println!("{} {}", colored("[PASS]", BOLD_GREEN), name);
+            }
+            pass = declared.len() as i32;
+        } else {
+            println!("{} testsuite", colored("[FAIL]", BOLD_RED));
+            fail = 1;
+        }
+    }
+
+    let total = if parsed_any || declared.is_empty() {
+        pass + skip + fail
+    } else {
+        declared.len() as i32
+    };
+
+    println!();
+    println!("{}", colored("=====================", BOLD_GREEN));
+    println!("{}", colored("  Testsuite summary  ", BOLD_GREEN));
+    println!("{}", colored("=====================", BOLD_GREEN));
+    println!("TOTAL: {}", total);
+    print_field("PASS", pass, BOLD_GREEN);
+    print_field("SKIP", skip, BOLD_BLUE);
+    print_field("FAIL", fail, BOLD_RED);
+    println!("{}", colored("=====================", BOLD_GREEN));
+
+    if fail > 0 || !suite_success {
+        return Ok(1);
+    }
+    Ok(0)
+}
+
+fn collect_test_sources() -> Result<Vec<PathBuf>, String> {
+    let tests_dir = Path::new("./tests");
+    if !tests_dir.is_dir() {
+        return Ok(Vec::new());
+    }
+    let mut sources = Vec::new();
+    for entry in fs::read_dir(tests_dir).map_err(|e| format!("Failed to read tests/: {e}"))? {
+        let path = entry
+            .map_err(|e| format!("Failed to read tests/: {e}"))?
+            .path();
+        if path.extension().and_then(|v| v.to_str()) == Some("c") {
+            sources.push(path);
+        }
+    }
+    sources.sort();
+    Ok(sources)
+}
+
+fn test_include_dirs(config: &Config, profile: &str) -> Vec<String> {
+    let mut dirs = vec![
+        "./tests".to_string(),
+        "./src".to_string(),
+        "./target/include".to_string(),
+    ];
+    dirs.extend(get_list_with_profile(config, "include", profile));
+    dirs
+}
+
+fn compile_test_source(
+    compiler: &str,
+    standard: &str,
+    cflags: &[String],
+    includes: &[String],
+    source: &Path,
+    obj_path: &Path,
+) -> Result<(), String> {
+    let mut cmd = Command::new(compiler);
+    cmd.arg("-c").arg(source).arg("-o").arg(obj_path);
+    if !standard.trim().is_empty() {
+        cmd.arg(format!("-std={}", standard.trim()));
+    }
+    for flag in cflags {
+        cmd.arg(flag);
+    }
+    for dir in includes {
+        cmd.arg(format!("-I{dir}"));
+    }
+    let output = cmd
+        .output()
+        .map_err(|e| format!("Failed to compile {}: {e}", source.display()))?;
+    print_command_output(&output);
+    if !output.status.success() {
+        return Err(format!("Compilation of {} failed", source.display()));
+    }
+    Ok(())
+}
+
+fn link_test_binary(
+    compiler: &str,
+    ldflags: &[String],
+    project_lib: Option<&str>,
+    obj_path: &Path,
+    bin_path: &Path,
+) -> Result<(), String> {
+    let mut cmd = Command::new(compiler);
+    cmd.arg(obj_path);
+    if let Some(name) = project_lib {
+        cmd.arg("-Ltarget/lib").arg(format!("-l{name}"));
+    }
+    for flag in ldflags {
+        cmd.arg(flag);
+    }
+    cmd.arg("-o").arg(bin_path);
+    let output = cmd
+        .output()
+        .map_err(|e| format!("Failed to link {}: {e}", bin_path.display()))?;
+    print_command_output(&output);
+    if !output.status.success() {
+        return Err(format!("Linking of {} failed", bin_path.display()));
+    }
+    Ok(())
+}
+
+fn print_command_output(output: &std::process::Output) {
+    if !output.stdout.is_empty() {
+        print!("{}", String::from_utf8_lossy(&output.stdout));
+    }
+    if !output.stderr.is_empty() {
+        eprint!("{}", String::from_utf8_lossy(&output.stderr));
+    }
+}
+
+fn ensure_test_header() -> Result<(), String> {
+    fs::create_dir_all("./tests").map_err(|_| "Failed to create tests/".to_string())?;
+    fs::write("./tests/dcr_test.h", FILE_DCR_TEST_H)
+        .map_err(|_| "Failed to write tests/dcr_test.h".to_string())?;
+    println!("Created tests/dcr_test.h");
+    fs::write("./tests/test.c", FILE_TEST_C)
+        .map_err(|_| "Failed to write tests/test.c".to_string())?;
+    println!("Created tests/test.c");
+    Ok(())
+}
+
+fn extract_test_names_path(path: &Path) -> Vec<String> {
+    let Ok(content) = fs::read_to_string(path) else {
+        return Vec::new();
+    };
+    let mut names = Vec::new();
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if let Some(rest) = trimmed.strip_prefix("TEST_CASE(")
+            && let Some(name) = rest.strip_suffix("),")
+        {
+            names.push(name.to_string());
+        }
+    }
+    names
+}
+
+fn print_field(label: &str, value: i32, color: &str) {
+    if value == 0 {
+        println!("{}:  {}", label, value);
+    } else {
+        println!("{}{}:  {}{}", color, label, value, RESET);
+    }
+}

src/cli/tree.rs

@@ -0,0 +1,135 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::config::Config;
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_CYAN, printc};
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use toml::Value;
+
+pub fn tree(_args: &[String]) -> i32 {
+    let current_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let config = match Config::open("dcr.toml") {
+        Ok(c) => c,
+        Err(_) => {
+            error("dcr.toml not found in current directory");
+            return 1;
+        }
+    };
+
+    let name = config
+        .get("package.name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("unknown");
+    let version = config
+        .get("package.version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("0.0.0");
+
+    printc(&format!("{} v{}", name, version), BOLD_CYAN);
+
+    let mut seen = HashSet::new();
+    seen.insert(name.to_string());
+
+    if let Some(deps) = config.get("dependencies").and_then(|v| v.as_table()) {
+        print_deps(deps, &current_dir, "", &mut seen);
+    }
+
+    0
+}
+
+fn print_deps(
+    deps: &toml::value::Table,
+    base_path: &Path,
+    prefix: &str,
+    seen: &mut HashSet<String>,
+) {
+    let mut dep_list: Vec<_> = deps.iter().collect();
+    dep_list.sort_by_key(|(name, _)| *name);
+
+    for (i, (name, value)) in dep_list.iter().enumerate() {
+        let is_last = i == dep_list.len() - 1;
+        let connector = if is_last { "└── " } else { "├── " };
+        let child_prefix = if is_last { "    " } else { "│   " };
+
+        let dep_path = resolve_dep_path(value, base_path);
+        let mut version = String::new();
+        let mut sub_deps = None;
+        let mut resolved_path = None;
+
+        if let Some(path) = &dep_path {
+            let dcr_toml = path.join("dcr.toml");
+            if dcr_toml.exists()
+                && let Ok(config) = Config::open(&dcr_toml.to_string_lossy())
+            {
+                if let Some(v) = config.get("package.version").and_then(|v| v.as_str()) {
+                    version = format!(" v{}", v);
+                }
+                sub_deps = config
+                    .get("dependencies")
+                    .and_then(|v| v.as_table())
+                    .cloned();
+                resolved_path = Some(path.clone());
+            }
+        }
+
+        if version.is_empty() {
+            version = match value {
+                Value::String(s) if s.starts_with("git:") || s.starts_with("github:") => {
+                    format!(" ({})", s)
+                }
+                Value::Table(t) => {
+                    if let Some(v) = t.get("version").and_then(|v| v.as_str()) {
+                        format!(" v{}", v)
+                    } else if let Some(git) = t.get("git").and_then(|v| v.as_str()) {
+                        format!(" ({})", git)
+                    } else {
+                        "".to_string()
+                    }
+                }
+                _ => "".to_string(),
+            };
+        }
+
+        println!("{}{}{}{}", prefix, connector, name, version);
+
+        if let Some(s_deps) = sub_deps
+            && !seen.contains(*name)
+        {
+            seen.insert(name.to_string());
+            let new_prefix = format!("{}{}", prefix, child_prefix);
+            if let Some(path) = resolved_path {
+                print_deps(&s_deps, &path, &new_prefix, seen);
+            }
+            seen.remove(*name);
+        }
+    }
+}
+
+fn resolve_dep_path(value: &Value, base_path: &Path) -> Option<PathBuf> {
+    match value {
+        Value::String(s) => s
+            .strip_prefix("path:")
+            .map(|stripped| base_path.join(stripped)),
+        Value::Table(t) => t
+            .get("path")
+            .and_then(|v| v.as_str())
+            .map(|path| base_path.join(path)),
+        _ => None,
+    }
+}

src/config.rs

@@ -1,3 +1,20 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 pub const PROFILE: &str = "debug";
 pub const FILE_MAIN_C: &str = r#"#include <stdio.h>
 
@@ -7,16 +24,88 @@ int main(void) {
 }
 "#;
 
+pub const FILE_DCR_TEST_H: &str = r#"#pragma once
+#include <stdio.h>
+#include <string.h>
+
+#define DCR_TEST_PASS 0
+#define DCR_TEST_FAIL 1
+#define DCR_TEST_SKIP 2
+
+#define EXPECT(expr) \
+    do { \
+        if (!(expr)) { \
+            fprintf(stderr, "assert failed: %s (%s:%d)\n", #expr, __FILE__, __LINE__); \
+            return DCR_TEST_FAIL; \
+        } \
+    } while (0)
+
+#define SKIP(reason) \
+    do { \
+        (void)(reason); \
+        return DCR_TEST_SKIP; \
+    } while (0)
+
+#define TEST(name) static int name(void)
+#define TEST_CASE(name) {#name, name}
+
+typedef int (*test_fn_t)(void);
+
+typedef struct {
+    const char *name;
+    test_fn_t fn;
+} test_case_t;
+
+static inline int dcr_test_raw_mode(int argc, char **argv) {
+    return argc > 1 && strcmp(argv[1], "--dcr-raw") == 0;
+}
+
+static inline void dcr_test_print_result(const char *name, int rc, int raw_mode) {
+    const char *tag = (rc == DCR_TEST_PASS) ? "PASS" : (rc == DCR_TEST_SKIP) ? "SKIP" : "FAIL";
+    if (raw_mode) {
+        printf("%s\t%s\n", tag, name);
+    } else {
+        printf("[%s] %s\n", tag, name);
+    }
+}
+"#;
+
+pub const FILE_TEST_C: &str = r#"#include "dcr_test.h"
+
+TEST(test_example) {
+    EXPECT(1 + 1 == 2);
+    return DCR_TEST_PASS;
+}
+
+static test_case_t CASES[] = {
+    TEST_CASE(test_example),
+};
+
+int main(int argc, char **argv) {
+    int raw = dcr_test_raw_mode(argc, argv);
+    int rc = 0;
+    int count = (int)(sizeof(CASES) / sizeof(CASES[0]));
+    for (int i = 0; i < count; ++i) {
+        int status = CASES[i].fn();
+        dcr_test_print_result(CASES[i].name, status, raw);
+        if (status == DCR_TEST_FAIL) {
+            rc = 1;
+        }
+    }
+    return rc;
+}
+"#;
+
 pub fn flags(profile: &str) -> Option<&'static [&'static str]> {
     match profile {
-        "release" => Some(&["-O3", "-DNDEBUG", "-march=native"]),
+        "release" => Some(&["-O3", "-DNDEBUG"]),
         "debug" => Some(&[
             "-O0",
             "-g",
             "-Wall",
             "-Wextra",
             "-fno-omit-frame-pointer",
-            "-DDEBUG",
+            "-DDCR_DEBUG",
         ]),
         _ => None,
     }

src/core/builder/clang.rs

@@ -1,250 +0,0 @@
-use crate::core::builder::BuildContext;
-use crate::platform;
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::time::Instant;
-
-pub fn build(ctx: &BuildContext) -> Result<f64, String> {
-    let compiler = if ctx.compiler.is_empty() {
-        "cc"
-    } else {
-        ctx.compiler
-    };
-    let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
-    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
-
-    if ctx.kind == "staticlib" {
-        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
-        let mut cmd = Command::new(ctx.archiver.unwrap_or("ar"));
-        cmd.arg("rcs").arg(&lib_path);
-        for obj in &objects {
-            cmd.arg(obj);
-        }
-        match cmd.status() {
-            Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-                return Ok(elapsed);
-            }
-            Ok(_) => return Err("Build failed".to_string()),
-            Err(err) => return Err(format!("Build failed: {err}")),
-        }
-    }
-
-    let mut cmd = Command::new(ctx.linker.unwrap_or(compiler));
-    if ctx.kind == "sharedlib" {
-        if cfg!(target_os = "macos") {
-            cmd.arg("-dynamiclib");
-        } else {
-            cmd.arg("-shared");
-        }
-    }
-    for obj in &objects {
-        cmd.arg(obj);
-    }
-    for flag in default_flags(ctx.profile) {
-        cmd.arg(flag);
-    }
-    for flag in ctx.cflags {
-        cmd.arg(flag);
-    }
-    for dir in ctx.lib_dirs {
-        cmd.arg(format!("-L{dir}"));
-    }
-    for lib in ctx.libs {
-        cmd.arg(format!("-l{lib}"));
-    }
-    for flag in ctx.ldflags {
-        cmd.arg(flag);
-    }
-    let out_path = if ctx.kind == "sharedlib" {
-        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
-    } else {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
-    };
-    cmd.arg("-o").arg(out_path);
-
-    match cmd.status() {
-        Ok(status) if status.success() => {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            Ok(elapsed)
-        }
-        Ok(_) => Err("Build failed".to_string()),
-        Err(err) => Err(format!("Build failed: {err}")),
-    }
-}
-
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"))
-            || (lang == "asm" && (ext == "s" || ext == "asm"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-fn normalize_source_path(path: &Path) -> String {
-    if !path.is_absolute() {
-        return path.to_string_lossy().to_string();
-    }
-    if let Ok(base) = std::env::current_dir()
-        && let Ok(rel) = path.strip_prefix(&base)
-    {
-        return format!("./{}", rel.to_string_lossy());
-    }
-    path.to_string_lossy().to_string()
-}
-
-fn default_flags(profile: &str) -> &'static [&'static str] {
-    match profile {
-        "release" => &["-O3", "-DNDEBUG", "-march=native"],
-        "debug" => &[
-            "-O0",
-            "-g",
-            "-Wall",
-            "-Wextra",
-            "-fno-omit-frame-pointer",
-            "-DDEBUG",
-        ],
-        _ => &[],
-    }
-}
-
-fn build_objects(
-    compiler: &str,
-    sources: &[String],
-    obj_dir: &Path,
-    ctx: &BuildContext,
-    obj_ext: &str,
-) -> Result<Vec<String>, String> {
-    let mut objects = Vec::new();
-    for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
-        if let Some(parent) = Path::new(&obj_path).parent() {
-            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
-        }
-        if needs_rebuild(source, &obj_path) {
-            let mut cmd = Command::new(compiler);
-            cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
-            if ctx.kind == "sharedlib" {
-                cmd.arg("-fPIC");
-            }
-            if let Some(flag) = asm_lang_flag(source) {
-                cmd.arg("-x").arg(flag);
-            }
-            if let Some(platform) = ctx.platform
-                && !platform.trim().is_empty()
-            {
-                cmd.arg(format!("-march={}", platform));
-            }
-            if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
-                cmd.arg(format!("-std={}", ctx.standard));
-            }
-            for flag in default_flags(ctx.profile) {
-                cmd.arg(flag);
-            }
-            for flag in ctx.cflags {
-                cmd.arg(flag);
-            }
-            for dir in ctx.include_dirs {
-                cmd.arg(format!("-I{dir}"));
-            }
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
-            }
-        }
-        objects.push(obj_path);
-    }
-    Ok(objects)
-}
-
-fn asm_lang_flag(source: &str) -> Option<&'static str> {
-    let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
-    match ext {
-        "S" => Some("assembler-with-cpp"),
-        "s" | "asm" => Some("assembler"),
-        _ => None,
-    }
-}
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-fn needs_rebuild(source: &str, object: &str) -> bool {
-    let src_time = fs::metadata(source).and_then(|m| m.modified());
-    let obj_time = fs::metadata(object).and_then(|m| m.modified());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/common.rs

@@ -0,0 +1,794 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::{Mutex, OnceLock};
+
+static OUTPUT_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
+
+pub fn get_output_lock() -> &'static Mutex<()> {
+    OUTPUT_MUTEX.get_or_init(|| Mutex::new(()))
+}
+
+pub fn collect_sources(
+    roots: &[PathBuf],
+    extensions: &[&str],
+    exclude_dirs: &[PathBuf],
+    include_paths: &[String],
+) -> Result<Vec<String>, String> {
+    let mut sources = Vec::new();
+    for root in roots {
+        collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
+    }
+    sources.sort();
+    Ok(sources)
+}
+
+fn collect_sources_rec(
+    dir: &Path,
+    extensions: &[&str],
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+    include_paths: &[String],
+) -> Result<(), String> {
+    let full_dir = if dir.is_absolute() {
+        dir.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir)
+    };
+    if is_excluded(&full_dir, exclude_dirs, include_paths) && include_paths.is_empty() {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
+    for entry in entries {
+        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
+        let path = entry.path();
+        if path.is_dir() {
+            if is_excluded(&path, exclude_dirs, include_paths) && include_paths.is_empty() {
+                continue;
+            }
+            collect_sources_rec(&path, extensions, out, exclude_dirs, include_paths)?;
+            continue;
+        }
+        if !path.is_file() {
+            continue;
+        }
+        if is_excluded(&path, exclude_dirs, include_paths) {
+            continue;
+        }
+        let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
+        let ext_lower = ext_raw.to_lowercase();
+        let matched = extensions
+            .iter()
+            .any(|allowed| *allowed == ext_raw || *allowed == ext_lower);
+        if matched {
+            out.push(normalize_source_path(&path));
+        }
+    }
+    Ok(())
+}
+
+pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[String]) -> bool {
+    if matches_patterns(path, include_paths, true) {
+        return false;
+    }
+    if matches_patterns(path, include_paths, false) {
+        return true;
+    }
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
+    if patterns.is_empty() {
+        return false;
+    }
+    let cwd = std::env::current_dir().ok();
+    let abs_path = if path.is_absolute() {
+        path.to_path_buf()
+    } else if let Some(base) = cwd.as_ref() {
+        base.join(path)
+    } else {
+        path.to_path_buf()
+    };
+    let abs = abs_path.to_string_lossy().replace('\\', "/");
+    let rel = cwd
+        .as_ref()
+        .and_then(|base| abs_path.strip_prefix(base).ok())
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+        .unwrap_or_default();
+    let rel_dot = if rel.is_empty() {
+        String::new()
+    } else {
+        format!("./{rel}")
+    };
+    for raw in patterns {
+        let trimmed = raw.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let is_neg = trimmed.starts_with('!');
+        if is_neg == positive {
+            continue;
+        }
+        let normalized = trimmed.trim_start_matches('!').replace('\\', "/");
+        if normalized.is_empty() {
+            continue;
+        }
+        if has_glob_magic(&normalized) {
+            let pat = match glob::Pattern::new(&normalized) {
+                Ok(p) => p,
+                Err(_) => continue,
+            };
+            if pat.matches(&abs)
+                || (!rel.is_empty() && (pat.matches(&rel) || pat.matches(&rel_dot)))
+            {
+                return true;
+            }
+            continue;
+        }
+        let norm = normalized.trim_end_matches('/');
+        let candidate = Path::new(norm);
+        let full = if candidate.is_absolute() {
+            candidate.to_path_buf()
+        } else if let Some(base) = cwd.as_ref() {
+            base.join(candidate)
+        } else {
+            candidate.to_path_buf()
+        };
+        if abs_path.starts_with(&full) {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn has_glob_magic(value: &str) -> bool {
+    value.chars().any(|c| matches!(c, '*' | '?' | '['))
+}
+
+pub fn parallel_build<F>(total_tasks: usize, task_fn: F) -> Result<(), String>
+where
+    F: Fn(usize) -> Result<(), String> + Sync + Send,
+{
+    let num_threads = std::thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(1);
+
+    let counter = std::sync::atomic::AtomicUsize::new(0);
+    let err_msg = std::sync::Mutex::new(None);
+
+    std::thread::scope(|s| {
+        for _ in 0..num_threads {
+            s.spawn(|| {
+                loop {
+                    if err_msg.lock().unwrap().is_some() {
+                        break;
+                    }
+
+                    let i = counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    if i >= total_tasks {
+                        break;
+                    }
+
+                    if let Err(e) = task_fn(i) {
+                        let mut err = err_msg.lock().unwrap();
+                        if err.is_none() {
+                            *err = Some(e);
+                        }
+                        break;
+                    }
+                }
+            });
+        }
+    });
+
+    if let Some(err) = err_msg.into_inner().unwrap() {
+        return Err(err);
+    }
+
+    Ok(())
+}
+
+pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
+    let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
+    let _guard = OUTPUT_MUTEX.get_or_init(|| Mutex::new(())).lock().unwrap();
+    if !output.stdout.is_empty() {
+        print!("{}", String::from_utf8_lossy(&output.stdout));
+    }
+    if !output.stderr.is_empty() {
+        eprint!("{}", String::from_utf8_lossy(&output.stderr));
+    }
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err("Build failed".to_string())
+    }
+}
+
+pub fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
+pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+    let src_path = Path::new(source);
+    let stripped = src_path.strip_prefix("./").unwrap_or(src_path);
+    let rel = stripped
+        .components()
+        .skip(1)
+        .collect::<std::path::PathBuf>();
+    let rel = if rel.components().next().is_some() {
+        rel
+    } else {
+        stripped.to_path_buf()
+    };
+    let mut out = obj_dir.join(rel);
+    let ext = out
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("")
+        .to_string();
+    let obj_ext = obj_ext.trim_start_matches('.');
+    if !ext.is_empty() {
+        let stem = out
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .unwrap_or("")
+            .to_string();
+        out.set_file_name(format!("{stem}.{ext}.{obj_ext}"));
+    } else {
+        out.set_extension(obj_ext);
+    }
+    out.to_string_lossy().to_string()
+}
+
+pub fn needs_rebuild(source: &str, object: &str) -> bool {
+    let src_time = fs::metadata(source).and_then(|m| m.modified());
+    let obj_time = fs::metadata(object).and_then(|m| m.modified());
+    let o_time = match obj_time {
+        Ok(t) => t,
+        Err(_) => return true,
+    };
+    match src_time {
+        Ok(s) if s > o_time => return true,
+        Err(_) => return true,
+        _ => {}
+    }
+
+    let d_file = PathBuf::from(object).with_extension("d");
+    if let Ok(content) = fs::read_to_string(&d_file) {
+        let deps = parse_d_file(&content);
+        for dep in deps {
+            let dep_path = Path::new(&dep);
+            if dep_path == Path::new(object) || dep_path == Path::new(source) {
+                continue;
+            }
+            if let Ok(dep_meta) = fs::metadata(dep_path) {
+                if let Ok(dep_time) = dep_meta.modified()
+                    && dep_time > o_time
+                {
+                    return true;
+                }
+            } else {
+                return true; // Missing dependency triggers rebuild
+            }
+        }
+    }
+    false
+}
+
+pub fn needs_link(objects: &[String], output_path: &str) -> bool {
+    let out_meta = match fs::metadata(output_path) {
+        Ok(m) => m,
+        Err(_) => return true,
+    };
+    let out_time = match out_meta.modified() {
+        Ok(t) => t,
+        Err(_) => return true,
+    };
+    for obj in objects {
+        let obj_meta = match fs::metadata(obj) {
+            Ok(m) => m,
+            Err(_) => return true,
+        };
+        let obj_time = match obj_meta.modified() {
+            Ok(t) => t,
+            Err(_) => return true,
+        };
+        if obj_time > out_time {
+            return true;
+        }
+    }
+    false
+}
+
+fn parse_d_file(content: &str) -> Vec<String> {
+    let mut deps = Vec::new();
+    let mut target_end = 0;
+    let bytes = content.as_bytes();
+    for (i, &b) in bytes.iter().enumerate() {
+        if b == b':' {
+            if i == 1
+                && bytes[0].is_ascii_alphabetic()
+                && i + 1 < bytes.len()
+                && (bytes[i + 1] == b'\\' || bytes[i + 1] == b'/')
+            {
+                continue;
+            }
+            target_end = i + 1;
+            break;
+        }
+    }
+
+    let deps_str = if target_end > 0 {
+        &content[target_end..]
+    } else {
+        content
+    };
+
+    let mut current_path = String::new();
+    let mut in_escape = false;
+    let mut chars = deps_str.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        if in_escape {
+            if c == '\n' {
+            } else if c == '\r' {
+                if chars.peek() == Some(&'\n') {
+                    chars.next();
+                }
+            } else {
+                current_path.push(c);
+            }
+            in_escape = false;
+        } else if c == '\\' {
+            in_escape = true;
+        } else if c.is_whitespace() {
+            if !current_path.is_empty() {
+                deps.push(current_path.clone());
+                current_path.clear();
+            }
+        } else {
+            current_path.push(c);
+        }
+    }
+    if !current_path.is_empty() {
+        deps.push(current_path);
+    }
+    deps
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::path::PathBuf;
+    use std::sync::Mutex;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
+    static CWD_LOCK: Mutex<()> = Mutex::new(());
+
+    fn temp_dir(prefix: &str) -> PathBuf {
+        let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("dcr_test_{prefix}_{n}"));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn default_roots() -> Vec<PathBuf> {
+        vec![PathBuf::from("src")]
+    }
+
+    #[test]
+    fn object_path_basic() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/main.c", "o");
+        assert_eq!(result, "target/debug/obj/main.c.o");
+    }
+
+    #[test]
+    fn object_path_nested() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/core/utils.c", "o");
+        assert_eq!(result, "target/debug/obj/core/utils.c.o");
+    }
+
+    #[test]
+    fn object_path_no_prefix() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "src/main.c", "o");
+        assert_eq!(result, "target/debug/obj/main.c.o");
+    }
+
+    #[test]
+    fn object_path_msvc_ext() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/main.c", "obj");
+        assert_eq!(result, "target/debug/obj/main.c.obj");
+    }
+
+    #[test]
+    fn needs_link_no_output() {
+        let dir = temp_dir("link_no_out");
+        let obj1 = dir.join("test1.o");
+        let obj2 = dir.join("test2.o");
+        let out = dir.join("app");
+        fs::write(&obj1, "").unwrap();
+        fs::write(&obj2, "").unwrap();
+        let objs = vec![
+            obj1.to_string_lossy().to_string(),
+            obj2.to_string_lossy().to_string(),
+        ];
+        assert!(needs_link(&objs, &out.to_string_lossy()));
+    }
+
+    #[test]
+    fn needs_link_fresh() {
+        let dir = temp_dir("link_fresh");
+        let obj1 = dir.join("test1.o");
+        let obj2 = dir.join("test2.o");
+        let out = dir.join("app");
+        fs::write(&obj1, "").unwrap();
+        fs::write(&obj2, "").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&out, "").unwrap();
+        let objs = vec![
+            obj1.to_string_lossy().to_string(),
+            obj2.to_string_lossy().to_string(),
+        ];
+        assert!(!needs_link(&objs, &out.to_string_lossy()));
+    }
+
+    #[test]
+    fn needs_link_stale() {
+        let dir = temp_dir("link_stale");
+        let obj1 = dir.join("test1.o");
+        let obj2 = dir.join("test2.o");
+        let out = dir.join("app");
+        fs::write(&obj1, "").unwrap();
+        fs::write(&out, "").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj2, "").unwrap();
+        let objs = vec![
+            obj1.to_string_lossy().to_string(),
+            obj2.to_string_lossy().to_string(),
+        ];
+        assert!(needs_link(&objs, &out.to_string_lossy()));
+    }
+
+    #[test]
+    fn needs_rebuild_no_object() {
+        let dir = temp_dir("rebuild_no_obj");
+        let src = dir.join("test.c");
+        fs::write(&src, "int main() {}").unwrap();
+        let obj = dir.join("test.o");
+        assert!(needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn needs_rebuild_fresh() {
+        let dir = temp_dir("rebuild_fresh");
+        let src = dir.join("test.c");
+        let obj = dir.join("test.o");
+        fs::write(&src, "int main() {}").unwrap();
+        // Sleep briefly to ensure mtime difference
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj, "").unwrap();
+        assert!(!needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn needs_rebuild_stale() {
+        let dir = temp_dir("rebuild_stale");
+        let src = dir.join("test.c");
+        let obj = dir.join("test.o");
+        fs::write(&obj, "").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&src, "int main() { return 1; }").unwrap();
+        assert!(needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn is_excluded_match() {
+        let include: Vec<String> = Vec::new();
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(is_excluded(
+            Path::new("/project/src/vendor"),
+            &excluded,
+            &include
+        ));
+        assert!(is_excluded(
+            Path::new("/project/src/vendor/lib.c"),
+            &excluded,
+            &include
+        ));
+    }
+
+    #[test]
+    fn is_excluded_no_match() {
+        let include: Vec<String> = Vec::new();
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(!is_excluded(
+            Path::new("/project/src/main.c"),
+            &excluded,
+            &include
+        ));
+        assert!(!is_excluded(
+            Path::new("/other/vendor"),
+            &excluded,
+            &include
+        ));
+    }
+
+    #[test]
+    fn collect_sources_c_files() {
+        let dir = temp_dir("collect_c");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(src.join("utils.c"), "").unwrap();
+        fs::write(src.join("README.md"), "").unwrap(); // should be ignored
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+        assert!(sources.iter().any(|s| s.ends_with("main.c")));
+        assert!(sources.iter().any(|s| s.ends_with("utils.c")));
+    }
+
+    #[test]
+    fn collect_sources_cpp_files() {
+        let dir = temp_dir("collect_cpp");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("main.cpp"), "").unwrap();
+        fs::write(src.join("helper.cxx"), "").unwrap();
+        fs::write(src.join("other.cc"), "").unwrap();
+        fs::write(src.join("skip.c"), "").unwrap(); // should be ignored
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["cpp", "cxx", "cc"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 3);
+    }
+
+    #[test]
+    fn collect_sources_empty_dir() {
+        let dir = temp_dir("collect_empty");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("empty src should return Ok");
+        assert!(sources.is_empty(), "empty src should return empty vec");
+    }
+
+    #[test]
+    fn collect_sources_respects_excludes() {
+        let dir = temp_dir("collect_exclude");
+        let src = dir.join("src");
+        let vendor = src.join("vendor");
+        fs::create_dir_all(&vendor).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(vendor.join("lib.c"), "").unwrap(); // should be excluded
+
+        let exclude = vec![vendor.clone()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("main.c"));
+    }
+
+    #[test]
+    fn collect_sources_nested() {
+        let dir = temp_dir("collect_nested");
+        let src = dir.join("src");
+        let sub = src.join("core").join("deep");
+        fs::create_dir_all(&sub).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(sub.join("nested.c"), "").unwrap();
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let include: Vec<String> = Vec::new();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &[], &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+    }
+
+    #[test]
+    fn include_overrides_exclude() {
+        let dir = temp_dir("include_override");
+        let src = dir.join("src");
+        let boot = src.join("boot");
+        let arch = boot.join("arch");
+        fs::create_dir_all(&arch).unwrap();
+        fs::write(arch.join("start.s"), "").unwrap();
+        fs::write(boot.join("skip.c"), "").unwrap();
+
+        let exclude = vec![boot.clone()];
+        let include = vec!["src/boot/arch/**".to_string()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["s", "c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("start.s"));
+    }
+
+    #[test]
+    fn exclude_glob_with_include_override() {
+        let dir = temp_dir("exclude_glob");
+        let src = dir.join("src");
+        let legacy = src.join("legacy");
+        let allow = legacy.join("allow");
+        fs::create_dir_all(&allow).unwrap();
+        fs::write(legacy.join("skip.c"), "").unwrap();
+        fs::write(allow.join("keep.c"), "").unwrap();
+
+        let exclude = vec![dir.join("src"), dir.join(".")];
+        let include = vec![
+            "!src/legacy/**".to_string(),
+            "src/legacy/allow/**".to_string(),
+        ];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("keep.c"));
+    }
+
+    #[test]
+    fn exclude_glob_without_include_keeps_other_files() {
+        let dir = temp_dir("exclude_glob_only");
+        let src = dir.join("src");
+        let gen_dir = src.join("gen");
+        fs::create_dir_all(&gen_dir).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(gen_dir.join("skip.c"), "").unwrap();
+
+        let exclude: Vec<PathBuf> = Vec::new();
+        let include = vec!["!src/gen/**".to_string()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let roots = default_roots();
+        let result = collect_sources(&roots, &["c"], &exclude, &include);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("main.c"));
+    }
+
+    #[test]
+    fn normalize_relative_path() {
+        let result = normalize_source_path(Path::new("./src/main.c"));
+        assert_eq!(result, "./src/main.c");
+    }
+
+    #[test]
+    fn parse_d_file_gcc_format() {
+        let content = "target/obj/main.o: src/main.c src/utils.h \\\n src/core/types.h";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec!["src/main.c", "src/utils.h", "src/core/types.h"]);
+    }
+
+    #[test]
+    fn parse_d_file_msvc_format() {
+        let content = "target/obj/main.obj: \\\n  C:/sdk/include/windows.h \\\n  src/main.c";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec!["C:/sdk/include/windows.h", "src/main.c"]);
+    }
+
+    #[test]
+    fn needs_rebuild_header_modified() {
+        let dir = temp_dir("rebuild_header");
+        let src = dir.join("test.c");
+        let header = dir.join("test.h");
+        let obj = dir.join("test.o");
+        let d_file = dir.join("test.d");
+
+        fs::write(&src, "int main() {}").unwrap();
+        fs::write(&header, "#define A 1").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj, "").unwrap();
+
+        let d_content = format!(
+            "{}: {} {}",
+            obj.to_string_lossy(),
+            src.to_string_lossy(),
+            header.to_string_lossy()
+        );
+        fs::write(&d_file, d_content).unwrap();
+
+        assert!(
+            !needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            "should be fresh"
+        );
+
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&header, "#define A 2").unwrap(); // modify header
+
+        assert!(
+            needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            "changed header should trigger rebuild"
+        );
+    }
+}

src/core/builder/gas.rs

@@ -1,12 +1,31 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
-    if ctx.language.to_lowercase().as_str() != "asm" {
+    let lang = ctx.language.to_lowercase();
+    if lang.split(',').any(|p| p.trim() != "asm") {
         return Err("GAS backend requires build.language = \"asm\"".to_string());
     }
     let assembler = if ctx.compiler.is_empty() {
@@ -15,12 +34,19 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
+    let sources = collect_sources(ctx)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
     let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
     if ctx.kind == "staticlib" {
         let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        if !common::needs_link(&objects, &lib_path) {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            return Ok(elapsed);
+        }
         let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
             "lib"
         } else {
@@ -35,6 +61,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         for obj in &objects {
             cmd.arg(obj);
         }
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
         match cmd.status() {
             Ok(status) if status.success() => {
                 let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -65,13 +94,31 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    let out_path = if ctx.kind == "sharedlib" {
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
-        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    let ext = ctx.output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
     } else {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+        format!("{}.{}", name, ext)
     };
+
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
+    };
+
+    if !common::needs_link(&objects, &out_path) {
+        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+        return Ok(elapsed);
+    }
     cmd.arg("-o").arg(out_path);
 
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
     match cmd.status() {
         Ok(status) if status.success() => {
             let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -82,76 +129,14 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-pub(crate) fn collect_sources(
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
-    language: &str,
+    // GAS handles only lowercase .s files
-    exclude_dirs: &[PathBuf],
+    common::collect_sources(
-) -> Result<Vec<String>, String> {
+        ctx.source_roots,
-    let lang = language.to_lowercase();
+        &["s"],
-    let mut sources = Vec::new();
+        ctx.exclude_dirs,
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
+        ctx.include_paths,
-    sources.sort();
+    )
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
-        let ext = ext_raw.to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = lang == "asm" && ext == "s" && ext_raw == "s";
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-fn normalize_source_path(path: &Path) -> String {
-    if !path.is_absolute() {
-        return path.to_string_lossy().to_string();
-    }
-    if let Ok(base) = std::env::current_dir()
-        && let Ok(rel) = path.strip_prefix(&base)
-    {
-        return format!("./{}", rel.to_string_lossy());
-    }
-    path.to_string_lossy().to_string()
 }
 
 fn build_objects(
@@ -161,46 +146,38 @@ fn build_objects(
     ctx: &BuildContext,
     obj_ext: &str,
 ) -> Result<Vec<String>, String> {
-    let mut objects = Vec::new();
+    let objects: Vec<String> = sources
-    for source in sources {
+        .iter()
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        .map(|s| common::object_path(obj_dir, s, obj_ext))
-        if let Some(parent) = Path::new(&obj_path).parent() {
+        .collect();
-            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+
-        }
+    common::parallel_build(sources.len(), |i| {
-        if needs_rebuild(source, &obj_path) {
+        build_object(assembler, &sources[i], &objects[i], ctx)
-            let mut cmd = Command::new(assembler);
+    })?;
-            cmd.arg(source).arg("-o").arg(&obj_path);
+
-            for flag in ctx.cflags {
-                cmd.arg(flag);
-            }
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
-            }
-        }
-        objects.push(obj_path);
-    }
     Ok(objects)
 }
 
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+fn build_object(
-    let src_path = Path::new(source);
+    assembler: &str,
-    let rel = src_path
+    source: &str,
-        .strip_prefix("./src")
+    obj_path: &str,
-        .or_else(|_| src_path.strip_prefix("src"))
+    ctx: &BuildContext,
-        .unwrap_or(src_path);
+) -> Result<(), String> {
-    let mut out = obj_dir.join(rel);
+    if let Some(parent) = Path::new(obj_path).parent() {
-    out.set_extension(obj_ext.trim_start_matches('.'));
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
-    out.to_string_lossy().to_string()
-}
-
-fn needs_rebuild(source: &str, object: &str) -> bool {
-    let src_time = fs::metadata(source).and_then(|m| m.modified());
-    let obj_time = fs::metadata(object).and_then(|m| m.modified());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
     }
+
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg(source).arg("-o").arg(obj_path);
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    common::run_command_sync_output(&mut cmd)
 }

src/core/builder/gcc.rs

@@ -1,250 +0,0 @@
-use crate::core::builder::BuildContext;
-use crate::platform;
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::time::Instant;
-
-pub fn build(ctx: &BuildContext) -> Result<f64, String> {
-    let compiler = if ctx.compiler.is_empty() {
-        "cc"
-    } else {
-        ctx.compiler
-    };
-    let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
-    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
-
-    if ctx.kind == "staticlib" {
-        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
-        let mut cmd = Command::new(ctx.archiver.unwrap_or("ar"));
-        cmd.arg("rcs").arg(&lib_path);
-        for obj in &objects {
-            cmd.arg(obj);
-        }
-        match cmd.status() {
-            Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-                return Ok(elapsed);
-            }
-            Ok(_) => return Err("Build failed".to_string()),
-            Err(err) => return Err(format!("Build failed: {err}")),
-        }
-    }
-
-    let mut cmd = Command::new(ctx.linker.unwrap_or(compiler));
-    if ctx.kind == "sharedlib" {
-        if cfg!(target_os = "macos") {
-            cmd.arg("-dynamiclib");
-        } else {
-            cmd.arg("-shared");
-        }
-    }
-    for obj in &objects {
-        cmd.arg(obj);
-    }
-    for flag in default_flags(ctx.profile) {
-        cmd.arg(flag);
-    }
-    for flag in ctx.cflags {
-        cmd.arg(flag);
-    }
-    for dir in ctx.lib_dirs {
-        cmd.arg(format!("-L{dir}"));
-    }
-    for lib in ctx.libs {
-        cmd.arg(format!("-l{lib}"));
-    }
-    for flag in ctx.ldflags {
-        cmd.arg(flag);
-    }
-    let out_path = if ctx.kind == "sharedlib" {
-        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
-    } else {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
-    };
-    cmd.arg("-o").arg(out_path);
-
-    match cmd.status() {
-        Ok(status) if status.success() => {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            Ok(elapsed)
-        }
-        Ok(_) => Err("Build failed".to_string()),
-        Err(err) => Err(format!("Build failed: {err}")),
-    }
-}
-
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"))
-            || (lang == "asm" && (ext == "s" || ext == "asm"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-fn normalize_source_path(path: &Path) -> String {
-    if !path.is_absolute() {
-        return path.to_string_lossy().to_string();
-    }
-    if let Ok(base) = std::env::current_dir()
-        && let Ok(rel) = path.strip_prefix(&base)
-    {
-        return format!("./{}", rel.to_string_lossy());
-    }
-    path.to_string_lossy().to_string()
-}
-
-fn default_flags(profile: &str) -> &'static [&'static str] {
-    match profile {
-        "release" => &["-O3", "-DNDEBUG", "-march=native"],
-        "debug" => &[
-            "-O0",
-            "-g",
-            "-Wall",
-            "-Wextra",
-            "-fno-omit-frame-pointer",
-            "-DDEBUG",
-        ],
-        _ => &[],
-    }
-}
-
-fn build_objects(
-    compiler: &str,
-    sources: &[String],
-    obj_dir: &Path,
-    ctx: &BuildContext,
-    obj_ext: &str,
-) -> Result<Vec<String>, String> {
-    let mut objects = Vec::new();
-    for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
-        if let Some(parent) = Path::new(&obj_path).parent() {
-            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
-        }
-        if needs_rebuild(source, &obj_path) {
-            let mut cmd = Command::new(compiler);
-            cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
-            if ctx.kind == "sharedlib" {
-                cmd.arg("-fPIC");
-            }
-            if let Some(flag) = asm_lang_flag(source) {
-                cmd.arg("-x").arg(flag);
-            }
-            if let Some(platform) = ctx.platform
-                && !platform.trim().is_empty()
-            {
-                cmd.arg(format!("-march={}", platform));
-            }
-            if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
-                cmd.arg(format!("-std={}", ctx.standard));
-            }
-            for flag in default_flags(ctx.profile) {
-                cmd.arg(flag);
-            }
-            for flag in ctx.cflags {
-                cmd.arg(flag);
-            }
-            for dir in ctx.include_dirs {
-                cmd.arg(format!("-I{dir}"));
-            }
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
-            }
-        }
-        objects.push(obj_path);
-    }
-    Ok(objects)
-}
-
-fn asm_lang_flag(source: &str) -> Option<&'static str> {
-    let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
-    match ext {
-        "S" => Some("assembler-with-cpp"),
-        "s" | "asm" => Some("assembler"),
-        _ => None,
-    }
-}
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-fn needs_rebuild(source: &str, object: &str) -> bool {
-    let src_time = fs::metadata(source).and_then(|m| m.modified());
-    let obj_time = fs::metadata(object).and_then(|m| m.modified());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/mod.rs

@@ -1,8 +1,25 @@
-pub mod clang;
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pub mod common;
 pub mod gas;
-pub mod gcc;
 pub mod msvc;
 pub mod nasm;
+pub mod unix_cc;
 
 pub struct BuildContext<'a> {
     pub profile: &'a str,
@@ -10,21 +27,35 @@ pub struct BuildContext<'a> {
     pub compiler: &'a str,
     pub language: &'a str,
     pub standard: &'a str,
+    pub cxx_standard: &'a str,
+    pub target: Option<&'a str>,
     pub target_dir: Option<&'a str>,
     pub kind: &'a str,
     pub platform: Option<&'a str>,
     pub linker: Option<&'a str>,
     pub archiver: Option<&'a str>,
+    pub package_type: Option<&'a str>,
+    pub source_roots: &'a [std::path::PathBuf],
     pub exclude_dirs: &'a [std::path::PathBuf],
+    pub include_paths: &'a [String],
     pub include_dirs: &'a [String],
     pub lib_dirs: &'a [String],
     pub libs: &'a [String],
     pub cflags: &'a [String],
     pub ldflags: &'a [String],
+    pub output_filename: Option<&'a str>,
+    pub output_extension: Option<&'a str>,
+    pub verbose: bool,
 }
 
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     let compiler = ctx.compiler.to_lowercase();
+    if !check_compiler_exists(ctx.compiler) {
+        return Err(format!(
+            "Compiler not found: {}. Make sure it is installed and available in PATH.",
+            ctx.compiler
+        ));
+    }
     if compiler.contains("clang-cl") {
         return msvc::build(ctx);
     }
@@ -34,37 +65,30 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     if compiler.contains("nasm") {
         return nasm::build(ctx);
     }
-    if compiler.contains("gcc") || compiler.contains("g++") {
-        return gcc::build(ctx);
-    }
-    if compiler.contains("clang") || compiler.contains("clang++") {
-        return clang::build(ctx);
-    }
     if compiler == "cl" || compiler.contains("msvc") {
         return msvc::build(ctx);
     }
-    clang::build(ctx)
+    unix_cc::build(ctx)
+}
+
+fn check_compiler_exists(compiler: &str) -> bool {
+    let name = if compiler.is_empty() { "cc" } else { compiler };
+    std::process::Command::new(name)
+        .arg("--version")
+        .output()
+        .is_ok()
 }
 
 pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
     let compiler = ctx.compiler.to_lowercase();
-    if compiler.contains("clang-cl") {
+    if compiler.contains("clang-cl") || compiler == "cl" || compiler.contains("msvc") {
-        return msvc::collect_sources(ctx.language, ctx.exclude_dirs);
+        return msvc::collect_sources(ctx);
     }
     if compiler == "as" || compiler.contains("gas") {
-        return gas::collect_sources(ctx.language, ctx.exclude_dirs);
+        return gas::collect_sources(ctx);
     }
     if compiler.contains("nasm") {
-        return nasm::collect_sources(ctx.language, ctx.exclude_dirs);
+        return nasm::collect_sources(ctx);
     }
-    if compiler.contains("gcc") || compiler.contains("g++") {
+    unix_cc::collect_sources(ctx)
-        return gcc::collect_sources(ctx.language, ctx.exclude_dirs);
-    }
-    if compiler.contains("clang") || compiler.contains("clang++") {
-        return clang::collect_sources(ctx.language, ctx.exclude_dirs);
-    }
-    if compiler == "cl" || compiler.contains("msvc") {
-        return msvc::collect_sources(ctx.language, ctx.exclude_dirs);
-    }
-    clang::collect_sources(ctx.language, ctx.exclude_dirs)
 }