feat: set MAKE environment variable for NetBSD build process

fix: correct path for Snap package output in release workflow
feat: update snap packaging directory structure and fix NetBSD package installation command
2026-10-21 12:58:34 +00:00 · 2026-05-28 16:55:51 +08:00 · 2026-05-28 16:53:14 +08:00 · 2026-05-28 16:43:27 +08:00 · 2026-05-28 16:10:28 +08:00 · 2026-05-28 15:34:24 +08:00
62 changed files with 3338 additions and 663 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.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 -->
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.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. -->
--- a/.github/workflows/aur.yml
+++ b/.github/workflows/aur.yml
@@ -1,138 +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:
-    # Не публикуем dev/pre-release теги в AUR
-    if: "!contains(github.ref_name, '-')"
-    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
--- a/.github/workflows/dexoron-packages-index.yml
+++ b/.github/workflows/dexoron-packages-index.yml
@@ -0,0 +1,127 @@
+name: Dexoron Packages Index
+
+on:
+  workflow_dispatch:
+  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: Download Arch package artifact
+        if: ${{ github.event_name == 'workflow_run' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: arch-package
+          path: central-packages/archlinux/x86_64/
+          github-token: ${{ secrets.PACKAGES_REPO_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+        continue-on-error: true
+
+      - name: Download Debian package artifact
+        if: ${{ github.event_name == 'workflow_run' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: debian-package
+          path: central-packages/debian/
+          github-token: ${{ secrets.PACKAGES_REPO_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+        continue-on-error: true
+
+      - name: Download RPM package artifact
+        if: ${{ github.event_name == 'workflow_run' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: rpm-package
+          path: central-packages/rpm/x86_64/
+          github-token: ${{ secrets.PACKAGES_REPO_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+        continue-on-error: true
+
+      # --- ИНДЕКСАЦИЯ REPO ---
+
+      - name: Update Pacman Database (Inside Arch Container)
+        run: |
+          docker run --rm \
+            -v ${{ github.workspace }}/central-packages:/packages \
+            archlinux:latest \
+            bash -c '
+              cd /packages/archlinux/x86_64 && \
+              rm -f dexoron.db dexoron.files && \
+              shopt -s nullglob
+              packages=(*.pkg.tar.zst)
+              if [ ${#packages[@]} -gt 0 ]; then
+                echo "Found ${#packages[@]} Arch packages. Updating database..."
+                repo-add dexoron.db.tar.gz "${packages[@]}" && \
+                ln -sf dexoron.db.tar.gz dexoron.db && \
+                ln -sf dexoron.files.tar.gz dexoron.files
+              else
+                echo "No .pkg.tar.zst files found. Skipping."
+              fi
+            '
+
+      - name: Update Debian APT Repository Index
+        run: |
+          sudo apt-get update && sudo apt-get install -y dpkg-dev
+          cd central-packages/debian
+          
+          shopt -s nullglob
+          deb_packages=(*.deb)
+          
+          if [ ${#deb_packages[@]} -gt 0 ]; then
+            echo "Found ${#deb_packages[@]} Debian packages. Generating Packages.gz..."
+            # Генерируем индекс для плоского (flat) репозитория
+            dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz
+          else
+            echo "No .deb files found. Skipping Debian index update."
+          fi
+
+      - name: Update Fedora DNF Repository Index
+        run: |
+          sudo apt-get update && sudo apt-get install -y createrepo-c
+          cd central-packages/rpm/x86_64
+          
+          shopt -s nullglob
+          rpm_packages=(*.rpm)
+          
+          if [ ${#rpm_packages[@]} -gt 0 ]; then
+            echo "Found ${#rpm_packages[@]} RPM packages. Generating repodata..."
+            # Пересоздаем метаданные для dnf
+            createrepo_c .
+          else
+            echo "No .rpm files found. Skipping Fedora index update."
+          fi
+
+      # --- ПУШ ИЗМЕНЕНИЙ ---
+
+      - 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"
+          
+          # Проверяем изменения во всех трех целевых папках
+          if [ -n "$(git status --porcelain)" ]; then
+            git add archlinux/ debian/ rpm/
+            git commit -m "chore: update repositories index (arch, debian, rpm)"
+            git push
+          else
+            echo "No changes detected in repository databases."
+          fi
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -7,32 +7,81 @@ on:
  workflow_dispatch:
    inputs:
      tag:
-        description: "Tag to build and upload assets for (e.g. v0.6.5)"
+        description: "Tag to build (e.g. v0.6.7)"
        required: true
+      run_linux:
+        description: "Build Linux"
+        type: boolean
+        default: true
+      run_linux_packages:
+        description: "Build Linux Packages (.deb, .rpm, .snap, .pkg.tar.zst)"
+        type: boolean
+        default: true
+      run_aur:
+        description: "Update AUR packages (dcr & dcr-bin)"
+        type: boolean
+        default: false 
+      run_bsd:
+        description: "Build BSD"
+        type: boolean
+        default: true
+      run_macos:
+        description: "Build macOS"
+        type: boolean
+        default: true
+      run_windows:
+        description: "Build Windows"
+        type: boolean
+        default: true
+      run_publish:
+        description: "Publish to crates.io"
+        type: boolean
+        default: false
+      run_brew:
+        description: "Update Homebrew tap"
+        type: boolean
+        default: false

 permissions:
  contents: write

 jobs:
+  # ── Resolve Tag ────────────────────────────────────────────────────────────
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.value }}
+      version: ${{ steps.tag.outputs.version }}
+      prerelease: ${{ steps.tag.outputs.prerelease }}
+    steps:
+      - name: Resolve tag
+        id: tag
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            TAG="${{ github.event.inputs.tag }}"
+          else
+            TAG="${GITHUB_REF_NAME}"
+          fi
+          VERSION="${TAG#v}"
+          [[ "$TAG" == *"-"* ]] && PRERELEASE="true" || PRERELEASE="false"
+          echo "value=${TAG}"             >> "$GITHUB_OUTPUT"
+          echo "version=${VERSION}"       >> "$GITHUB_OUTPUT"
+          echo "prerelease=${PRERELEASE}" >> "$GITHUB_OUTPUT"
+
+  # ── Release Notes ──────────────────────────────────────────────────────────
  notes:
+    needs: setup
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
-          # При ручном запуске чекаутим нужный тег
-          ref: ${{ github.event.inputs.tag || github.ref }}
+          ref: ${{ needs.setup.outputs.tag }}

      - name: Prepare Release Notes
        shell: bash
        run: |
          set -euo pipefail
-          # При ручном запуске берём версию из инпута, иначе из тега
-          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
-            tag="${{ github.event.inputs.tag }}"
-            tag="${tag#v}"
-          else
-            tag="${GITHUB_REF_NAME#v}"
-          fi
+          tag="${{ needs.setup.outputs.version }}"
          notes_file=".github/release-notes.md"
          if grep -q "^## \\[${tag}\\]" CHANGELOG.md; then
            awk -v ver="$tag" '
@@ -51,60 +100,23 @@ jobs:
          name: release-notes
          path: .github/release-notes.md

-  build:
+  # ── Linux Binaries Matrix ──────────────────────────────────────────────────
+  build-linux:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_linux == 'true' }}
+    needs: [setup, notes]
+    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        include:
-          # ── Linux GNU ──────────────────────────────────────────────────────
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-            apt: gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
-            env_cc: CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
-            env_linker: CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
-
-          # ── Linux Musl ─────────────────────────────────────────────────────
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            apt: musl-tools
-            env_cc: CC_x86_64_unknown_linux_musl=musl-gcc
-            env_linker: CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=musl-gcc
-
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            musl_cross: aarch64-linux-musl-cross
-            env_cc: CC_aarch64_unknown_linux_musl=aarch64-linux-musl-gcc
-            env_linker: CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER=aarch64-linux-musl-gcc
-
-          # ── macOS ──────────────────────────────────────────────────────────
-          - os: macos-15-intel
-            target: x86_64-apple-darwin
-
-          - os: macos-latest
-            target: aarch64-apple-darwin
-
-          # ── Windows MSVC ───────────────────────────────────────────────────
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-
-          - os: windows-latest
-            target: aarch64-pc-windows-msvc
-
-          # ── Windows GNU ────────────────────────────────────────────────────
-          - os: windows-latest
-            target: x86_64-pc-windows-gnu
-
-          # gnullvm исключён: LLVM MinGW не предустановлен на GitHub Actions
-
-    runs-on: ${{ matrix.os }}
-    needs: notes
+          - target: x86_64-unknown-linux-gnu
+          - target: aarch64-unknown-linux-gnu
+          - target: x86_64-unknown-linux-musl
+          - target: aarch64-unknown-linux-musl
    steps:
      - uses: actions/checkout@v4
        with:
-          ref: ${{ github.event.inputs.tag || github.ref }}
+          ref: ${{ needs.setup.outputs.tag }}

      - name: Download Release Notes
        uses: actions/download-artifact@v4
@@ -112,70 +124,663 @@ jobs:
          name: release-notes
          path: .github

-      - name: Install cargo-zigbuild (Linux cross-compilation)
-        if: runner.os == 'Linux'
+      - name: Install cargo-zigbuild
        run: |
          pip install cargo-zigbuild
          echo "$HOME/.local/bin" >> $GITHUB_PATH

-      - name: Setup LLVM + MinGW (gnullvm)
-        if: contains(matrix.target, 'gnullvm')
-        shell: pwsh
-        run: |
-          choco install llvm mingw -y --no-progress
-          echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-
      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}

      - name: Build
-        shell: bash
        run: |
-          if [ "${{ runner.os }}" = "Linux" ] && [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
+          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
            cargo zigbuild --release --target ${{ matrix.target }}
          else
            cargo build --release --target ${{ matrix.target }}
          fi

-      - name: Derive version string
-        shell: bash
+      - name: Prepare Artifact
        run: |
-          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
-            RAW_TAG="${{ github.event.inputs.tag }}"
-          else
-            RAW_TAG="${GITHUB_REF_NAME}"
-          fi
-          echo "RELEASE_TAG=${RAW_TAG}" >> "$GITHUB_ENV"
-          echo "RELEASE_VERSION=${RAW_TAG#v}" >> "$GITHUB_ENV"
-
-      - name: Derive asset name (Unix)
-        if: runner.os != 'Windows'
-        shell: bash
-        run: |
-          echo "ASSET_NAME=dcr-${{ matrix.target }}-${RELEASE_VERSION}" >> "$GITHUB_ENV"
-
-      - name: Derive asset name (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          "ASSET_NAME=dcr-${{ matrix.target }}-$($env:RELEASE_VERSION).exe" >> $env:GITHUB_ENV
-
-      - name: Prepare Artifact (Unix)
-        if: runner.os != 'Windows'
-        shell: bash
-        run: cp target/${{ matrix.target }}/release/dcr "$ASSET_NAME"
-
-      - name: Prepare Artifact (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: Copy-Item "target/${{ matrix.target }}/release/dcr.exe" "$env:ASSET_NAME"
+          ASSET="dcr-${{ matrix.target }}-${{ needs.setup.outputs.version }}"
+          cp target/${{ matrix.target }}/release/dcr "$ASSET"
+          echo "ASSET_NAME=${ASSET}" >> "$GITHUB_ENV"

      - name: Upload Release Asset
        uses: softprops/action-gh-release@v2
        with:
-          tag_name: ${{ env.RELEASE_TAG }}
+          tag_name: ${{ needs.setup.outputs.tag }}
          files: ${{ env.ASSET_NAME }}
          body_path: .github/release-notes.md
-          prerelease: ${{ contains(env.RELEASE_TAG, '-') }}
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── Linux Packages Matrix (.deb, .rpm, .pkg.tar.zst, .snap) ────────────────
+  build-linux-packages:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_linux_packages == 'true' }}
+    needs: [setup, notes]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - package_type: deb
+            artifact_name: debian-package
+          - package_type: rpm
+            artifact_name: rpm-package
+          - package_type: arch
+            artifact_name: arch-package
+          - package_type: snap
+            artifact_name: snap-package
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - name: Setup Rust (For non-container builds)
+        if: matrix.package_type != 'arch'
+        uses: dtolnay/rust-toolchain@stable
+
+      # ── DEB Build ──
+      - name: Build Debian Package
+        if: matrix.package_type == 'deb'
+        run: |
+          cargo install cargo-deb
+          cargo build --release
+          cargo deb --no-build
+          mkdir -p dist-packages && cp target/debian/*.deb dist-packages/
+
+      # ── RPM Build ──
+      - name: Build RPM Package
+        if: matrix.package_type == 'rpm'
+        run: |
+          cargo install cargo-generate-rpm
+          cargo build --release
+          cargo generate-rpm
+          mkdir -p dist-packages && cp target/generate-rpm/*.rpm dist-packages/
+
+      # ── Snap Build ──
+      - name: Build Snap Package
+        if: matrix.package_type == 'snap'
+        run: |
+          cargo build --release
+          mkdir -p packaging/snap/dist/bin
+          cp target/release/dcr packaging/snap/dist/bin/
+
+      - name: Snapcraft Build Action
+        if: matrix.package_type == 'snap'
+        uses: snapcore/action-build@v1
+        with:
+          path: packaging/snap
+
+      - name: Prepare Snap Output
+        if: matrix.package_type == 'snap'
+        run: mkdir -p dist-packages && cp packaging/snap/*.snap dist-packages/
+
+      # ── Arch Linux Native Build ──
+      - name: Build Arch Package inside Container
+        if: matrix.package_type == 'arch'
+        run: |
+          PKGVER='${{ needs.setup.outputs.version }}'
+          TAG='${{ needs.setup.outputs.tag }}'
+          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/${TAG}.tar.gz"
+          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
+          mkdir -p arch-build
+          cat > arch-build/PKGBUILD <<PKG
+          pkgname=dcr
+          pkgver=${PKGVER}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects"
+          arch=('x86_64')
+          url="https://github.com/dexoron/dcr"
+          license=('GPL-3.0-or-later')
+          depends=('gcc-libs')
+          makedepends=('cargo')
+          options=('!lto')
+          source=("\$pkgname-\$pkgver.tar.gz::\$url/archive/refs/tags/v\$pkgver.tar.gz")
+          sha256sums=('${SHA256}')
+          build() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            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
+          docker run --rm \
+            -v ${{ github.workspace }}/arch-build:/build \
+            archlinux:latest \
+            bash -c "
+              pacman -Syu --noconfirm base-devel cargo gcc-libs git && \
+              useradd -m builduser && \
+              echo 'builduser ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers && \
+              chown -R builduser:builduser /build && \
+              cd /build && \
+              su builduser -c 'makepkg -s --noconfirm'
+            "
+          mkdir -p dist-packages && cp arch-build/*.pkg.tar.zst dist-packages/
+
+      # ── Upload Artifacts ──
+      - name: Upload Package Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact_name }}
+          path: dist-packages/*
+          if-no-files-found: ignore
+
+  # ── Publish Packages to Release (Out of Matrix) ────────────────────────────
+  publish-dexoron-packages:
+    needs: [setup, notes, build-linux-packages]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      - name: Download Built Packages
+        uses: actions/download-artifact@v4
+        with:
+          path: collected-packages
+
+      - name: Upload Everything to GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: |
+            collected-packages/debian-package/*
+            collected-packages/rpm-package/*
+            collected-packages/arch-package/*
+            collected-packages/snap-package/*
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── macOS Matrix ───────────────────────────────────────────────────────────
+  build-macos:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_macos == 'true' }}
+    needs: [setup, notes]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-15-intel
+            target: x86_64-apple-darwin
+          - os: macos-latest
+            target: aarch64-apple-darwin
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Prepare Artifact
+        run: |
+          ASSET="dcr-${{ matrix.target }}-${{ needs.setup.outputs.version }}"
+          cp target/${{ matrix.target }}/release/dcr "$ASSET"
+          echo "ASSET_NAME=${ASSET}" >> "$GITHUB_ENV"
+
+      - name: Upload Release Asset
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: ${{ env.ASSET_NAME }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── BSD Systems Matrix ─────────────────────────────────────────────────────
+  build-bsd:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_bsd == 'true' }}
+    needs: [setup, notes]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        system: [freebsd, openbsd, netbsd]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      # --- FREEBSD ---
+      - name: Build in FreeBSD VM
+        if: matrix.system == 'freebsd'
+        uses: vmactions/freebsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
+            pkg install -y rust perl5 gmake
+            cargo build --release
+
+      - name: Prepare FreeBSD Artifact
+        if: matrix.system == 'freebsd'
+        run: |
+          ASSET="dcr-x86_64-unknown-freebsd-${{ needs.setup.outputs.version }}"
+          cp target/release/dcr "$ASSET"
+          echo "BSD_ASSET=${ASSET}" >> "$GITHUB_ENV"
+
+      # --- OPENBSD ---
+      - name: Build in OpenBSD VM
+        if: matrix.system == 'openbsd'
+        uses: vmactions/openbsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            export PATH="/usr/local/bin:$PATH"
+            pkg_add rust perl gmake
+            cargo build --release
+
+      - name: Prepare OpenBSD Artifact
+        if: matrix.system == 'openbsd'
+        run: |
+          ASSET="dcr-x86_64-unknown-openbsd-${{ needs.setup.outputs.version }}"
+          cp target/release/dcr "$ASSET"
+          echo "BSD_ASSET=${ASSET}" >> "$GITHUB_ENV"
+
+      # --- NETBSD ---
+      - name: Build in NetBSD VM
+        if: matrix.system == 'netbsd'
+        uses: vmactions/netbsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            export PATH="/usr/pkg/bin:/usr/pkg/sbin:$PATH"
+            pkg_add rust perl gmake
+            export MAKE=gmake
+            cargo build --release
+
+      - name: Prepare NetBSD Artifact
+        if: matrix.system == 'netbsd'
+        run: |
+          ASSET="dcr-x86_64-unknown-netbsd-${{ needs.setup.outputs.version }}"
+          cp target/release/dcr "$ASSET"
+          echo "BSD_ASSET=${ASSET}" >> "$GITHUB_ENV"
+
+      # --- UPLOAD TARGET ---
+      - name: Upload BSD Asset to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: ${{ env.BSD_ASSET }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── Windows Matrix ─────────────────────────────────────────────────────────
+  build-windows:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_windows == 'true' }}
+    needs: [setup, notes]
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: x86_64-pc-windows-msvc
+          - target: aarch64-pc-windows-msvc
+          - target: x86_64-pc-windows-gnu
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Prepare Artifact
+        shell: pwsh
+        run: |
+          $asset = "dcr-${{ matrix.target }}-${{ needs.setup.outputs.version }}.exe"
+          Copy-Item "target/${{ matrix.target }}/release/dcr.exe" "$asset"
+          "ASSET_NAME=$asset" >> $env:GITHUB_ENV
+
+      - name: Upload Release Asset
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: ${{ env.ASSET_NAME }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+ 
+  # ── Arch User Repository (dcr) ───────────────────────────────────
+  publish-aur:
+    if: ${{ (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') || github.event.inputs.run_aur == 'true' }}
+    needs: [setup]
+    runs-on: ubuntu-latest
+    environment: aur
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Derive checksum
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/${{ needs.setup.outputs.tag }}.tar.gz"
+          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
+          echo "source_url=$SRC_URL" >> "$GITHUB_OUTPUT"
+          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
+
+      - name: Render AUR metadata
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKGVER='${{ needs.setup.outputs.version }}'
+          SRC_URL='${{ steps.meta.outputs.source_url }}'
+          SHA256='${{ steps.meta.outputs.sha256 }}'
+
+          mkdir -p packages/aur/dcr
+          cat > packages/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=('GPL-3.0-or-later')
+          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 > packages/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 = GPL-3.0-or-later
+            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
+          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 packages/aur/dcr/PKGBUILD aur-repo/PKGBUILD
+          cp packages/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 ${{ needs.setup.outputs.version }}"
+          git push
+
+  # ── Arch User Repository (dcr-bin) ────────────────────────────────
+  publish-aur-bin:
+    if: ${{ (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') || github.event.inputs.run_aur == 'true' }}
+    needs: [setup, build-linux]
+    runs-on: ubuntu-latest
+    environment: aur
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Derive checksum
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+          BIN_URL="https://github.com/dexoron/dcr/releases/download/${{ needs.setup.outputs.tag }}/dcr-x86_64-unknown-linux-musl-${{ needs.setup.outputs.version }}"
+          SHA256="$(curl -fsSL "$BIN_URL" | sha256sum | awk '{print $1}')"
+          echo "bin_url=$BIN_URL" >> "$GITHUB_OUTPUT"
+          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
+
+      - name: Render AUR Metadata
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKGVER='${{ needs.setup.outputs.version }}'
+          BIN_URL='${{ steps.meta.outputs.bin_url }}'
+          SHA256='${{ steps.meta.outputs.sha256 }}'
+
+          mkdir -p packages/aur/dcr-bin
+          cat > packages/aur/dcr-bin/PKGBUILD <<PKG
+          pkgname=dcr-bin
+          pkgver=${PKGVER}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects (pre-compiled musl binary)"
+          arch=('x86_64')
+          url="https://github.com/dexoron/dcr"
+          license=('GPL-3.0-or-later')
+          provides=('dcr')
+          conflicts=('dcr')
+          optdepends=(
+            'gcc: build C/C++ projects with GCC'
+            'clang: build C/C++ projects with Clang'
+          )
+          source_x86_64=("dcr-\$pkgver::${BIN_URL}")
+          sha256sums_x86_64=('${SHA256}')
+
+          package() {
+            install -Dm755 "\$srcdir/dcr-\$pkgver" "\$pkgdir/usr/bin/dcr"
+          }
+          PKG
+
+          cat > packages/aur/dcr-bin/.SRCINFO <<SRC
+          pkgbase = dcr-bin
+            pkgdesc = Cargo-like utility to manage C/C++ projects (pre-compiled musl binary)
+            pkgver = ${PKGVER}
+            pkgrel = 1
+            url = https://github.com/dexoron/dcr
+            arch = x86_64
+            license = GPL-3.0-or-later
+            provides = dcr
+            conflicts = dcr
+            optdepends = gcc: build C/C++ projects with GCC
+            optdepends = clang: build C/C++ projects with Clang
+            source_x86_64 = dcr-${PKGVER}::${BIN_URL}
+            sha256sums_x86_64 = ${SHA256}
+
+          pkgname = dcr-bin
+          SRC
+
+      - name: Push to AUR
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          AUR_PACKAGE: dcr-bin
+        shell: bash
+        run: |
+          set -euo pipefail
+          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 packages/aur/dcr-bin/PKGBUILD aur-repo/PKGBUILD
+          cp packages/aur/dcr-bin/.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-bin ${{ needs.setup.outputs.version }}"
+          git push
+
+  # ── crates.io ──────────────────────────────────────────────────────────────
+  publish-crates:
+    if: |
+      (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') ||
+      (github.event_name == 'workflow_dispatch' && github.event.inputs.run_publish == 'true')
+    needs: [setup, build-linux, build-macos, build-windows, build-bsd]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Publish to crates.io
+        run: cargo publish
+
+  # ── Homebrew tap ───────────────────────────────────────────────────────────
+  publish-brew:
+    if: |
+      (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') ||
+      (github.event_name == 'workflow_dispatch' && github.event.inputs.run_brew == 'true')
+    needs: [setup, build-linux, build-macos]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download release assets and compute sha256
+        id: sha
+        run: |
+          VERSION="${{ needs.setup.outputs.version }}"
+          BASE="https://github.com/dexoron/dcr/releases/download/v${VERSION}"
+
+          download_sha() {
+            curl -fsSL "${BASE}/$1" | sha256sum | awk '{print $1}'
+          }
+
+          echo "linux_x86=$(download_sha "dcr-x86_64-unknown-linux-gnu-${VERSION}")"     >> "$GITHUB_OUTPUT"
+          echo "linux_arm=$(download_sha "dcr-aarch64-unknown-linux-gnu-${VERSION}")"    >> "$GITHUB_OUTPUT"
+          echo "macos_x86=$(download_sha "dcr-x86_64-apple-darwin-${VERSION}")"          >> "$GITHUB_OUTPUT"
+          echo "macos_arm=$(download_sha "dcr-aarch64-apple-darwin-${VERSION}")"         >> "$GITHUB_OUTPUT"
+
+      - name: Checkout homebrew-dexoron
+        uses: actions/checkout@v4
+        with:
+          repository: dexoron/homebrew-dexoron
+          token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+
+      - name: Update Formula/dcr.rb
+        run: |
+          VERSION="${{ needs.setup.outputs.version }}"
+          cat > Formula/dcr.rb <<FORMULA
+          class Dcr < Formula
+            desc "Cargo-like utility to manage C/C++ projects"
+            homepage "https://dcr.dexoron.su"
+            version "${VERSION}"
+
+            on_macos do
+              on_intel do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-x86_64-apple-darwin-#{version}"
+                sha256 "${{ steps.sha.outputs.macos_x86 }}"
+              end
+              on_arm do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-aarch64-apple-darwin-#{version}"
+                sha256 "${{ steps.sha.outputs.macos_arm }}"
+              end
+            end
+
+            on_linux do
+              on_intel do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-x86_64-unknown-linux-gnu-#{version}"
+                sha256 "${{ steps.sha.outputs.linux_x86 }}"
+              end
+              on_arm do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-aarch64-unknown-linux-gnu-#{version}"
+                sha256 "${{ steps.sha.outputs.linux_arm }}"
+              end
+            end
+
+            def install
+              bin.install Dir["dcr*"].first => "dcr"
+            end
+
+            test do
+              system "#{bin}/dcr", "--version"
+            end
+          end
+          FORMULA
+
+      - name: Commit and push
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Formula/dcr.rb
+          git diff --staged --quiet && echo "No changes" && exit 0
+          git commit -m "dcr ${{ needs.setup.outputs.version }}"
+          git push
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,103 @@
 # Changelog

+## [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:
@@ -8,11 +106,13 @@ Added:
 - `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`.
@@ -158,10 +258,10 @@ Added:
 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)
+- - `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
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -31,7 +31,8 @@ DCR supports cross-compilation via `--target <triple>` or short names:
 - `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]
  targets = ["linux", "macos"]

@@ -41,6 +42,7 @@ DCR supports cross-compilation via `--target <triple>` or short names:
  [build.macos]
  compiler = "clang"
  ```
+
 - If no `--target`, builds for targets in `build.targets` or native if empty.

 ## Checks
@@ -70,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
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -112,7 +112,7 @@ dependencies = [

 [[package]]
 name = "dcr"
-version = "0.6.7"
+version = "0.6.9"
 dependencies = [
 "ctrlc",
 "git2",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,8 +1,37 @@
 [package]
 name = "dcr"
-version = "0.6.7"
+version = "0.6.9"
 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"
@@ -11,9 +40,9 @@ serde = { version = "1", features = ["derive"] }
 self-replace = "1"
 sha2 = "0.10"
 toml = "1.0.3"
-git2 = "0.20.4"
 serde_json = "1"
 ctrlc = "3"
+git2 = { version = "0.20.4", features = ["vendored-libgit2", "vendored-openssl"] }

 [target.'cfg(not(windows))'.dependencies]
-openssl = { version = "0.10", features = ["vendored"] }
+openssl = { version = "0.10", features = ["vendored"] }
--- a/FAQ.md
+++ b/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.
--- a/688
+++ b/688
@@ -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
-of this software and associated documentation files (the "Software"), to deal
-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:
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>

-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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
-SOFTWARE.
+## Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+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>.
--- a/README.md
+++ b/README.md
@@ -1,256 +1,208 @@
-# 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
- Unified project structure without manual setup
- Simple commands for common tasks
- Transparent compilation and predictable build profiles
+[![CI](https://github.com/dexoron/dcr/actions/workflows/ci.yml/badge.svg)](https://github.com/dexoron/dcr/actions/workflows/ci.yml)
+[![GitHub Release](https://img.shields.io/github/v/release/dexoron/dcr)](https://github.com/dexoron/dcr/releases/latest)
+[![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/dexoron/dcr/releases)
+<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
- 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 IDE integration files (VS Code, CLion) and compilation databases
- Generate a minimal C project template
- Build static, shared libraries, UEFI PE32+ executables, and bare-metal ELF executables
- Dependency management:
-  - Git and Path dependencies with `dcr.lock`
-  - Registry-based dependency resolution
- Library packaging functionality (auto-generate `include/` and `lib/` for `type = "lib"` packages)
- ASM projects with NASM/GAS or via GCC/Clang
- Mixed language projects
- Cross-compilation with `--target` (full triple support and short names)
- Target-specific configurations and inheritance
- Update the binary via `dcr --update` (GitHub Releases)
+</div>

-## Supported Platforms
- Linux: x86_64/aarch64 (GNU and Musl)
- macOS: x86_64/aarch64
- Windows: x86_64/aarch64 (MSVC, GNU, LLVM)
+---
+
+## Why DCR?
+
+- **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
-
-**Arch Linux**
-```sh
-yay -S dcr # or paru and other AUR package managers
-```
-
-### From Source
+<table>
+<tr>
+<td><b>Arch Linux (AUR)</b></td>
+<td>

 ```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
+yay -S dcr
 ```

-### Via `install.sh` (Linux/macOS)
+</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>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 | bash
 ```

-### Via `install.ps1` (Windows)
+</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:
- download a prebuilt binary from GitHub Releases
- or build the project from `git`
+</td>
+</tr>
+<tr>
+<td><b>From source</b></td>
+<td>

-Release assets:
- `dcr-x86_64-unknown-linux-gnu`
- `dcr-x86_64-apple-darwin`
- `dcr-aarch64-apple-darwin`
- `dcr-x86_64-pc-windows-msvc.exe`
+```sh
+git clone https://github.com/dexoron/dcr.git
+cd dcr && cargo build --release
+ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+```

-## 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:
-`dcr new hello`
-
-Or initialize the current directory (the directory must be empty):
-`dcr init`
-
-Project structure:
-
-```txt
-hello/
- src/
- - main.c
- dcr.toml
-```
-
-Build and run the project:
-`dcr run` or `dcr run --release`
-
-## Commands
-
-### `dcr new <name>`
-Creates a project with the specified name in the current directory.
-
-### `dcr init`
-Creates a project in the current directory. The project name is taken from the directory name. The directory must be empty.
-
-### `dcr setup`
-Initializes the registry system by reading `~/.dcr/config.toml` and verifying the availability of configured indices.
-
-### `dcr add <name> <source>`
-Adds a dependency to `dcr.toml`.
-If a registry is configured, `dcr` automatically finds the package.
-Git/Path syntax: `path:`, `github:`, `gitlab:`, `git:`, or a full URL.
-Use `--branch`, `--tag`, or `--rev` for Git dependencies.
-
-### `dcr build [profile]`
-Builds the project. If no profile is specified, `--debug` is used.
-Use `--force` to rebuild without cache, `--clean` to clean before build.
-
-### `dcr run [profile]`
-Builds the project and runs the binary. If no profile is specified, `--debug` is used.
-Use `--force` to rebuild without cache, `--clean` to clean before build.
-
-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.
-
-### `dcr gen`
-Generates IDE integration files and build tools.
- `dcr gen vscode`: VS Code workspace config
- `dcr gen clion`: CLion project files
- `dcr gen compile-commands`: `compile_commands.json` for clang tools
-
-### `dcr test`
-Runs the test suite.
-Use `dcr test --init` to create test files.
-
-## 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`.
-Profile-specific flags can be added via `[build.debug]` and `[build.release]`.
-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`).
-Use `build.kind = "efi"` to build a UEFI PE32+ executable (`.efi`).
-Use `build.kind = "elf"` to build a bare-metal ELF executable.
-`dcr run` is only for `build.kind = "bin"` and will fail for libraries, EFI, and ELF.
-Use `build.exclude`/`build.include` to control source/header collection.
-Use `build.roots` and `build.src_disable` to replace the default `src/` root.
-Use `build.steps` and `build.post_steps` to run custom commands.
-Use `build.clean` for extra cleanup paths and `[run].cmd` to override run command.
-
-## Cross-compilation
-
-DCR supports cross-compilation via `--target <triple>` or short names:
-
 ```sh
-dcr build --target linux --release    # x86_64-unknown-linux-gnu
-dcr build --target macos --release    # x86_64-apple-darwin
-dcr build --target windows --release  # x86_64-pc-windows-msvc
-dcr run --target aarch64-linux-gnu
+dcr new hello
+cd hello
+dcr run
 ```

-Configure multiple targets and target-specific settings in `dcr.toml`:
+**Project structure:**

-```toml
-[build.targets]
-targets = ["linux", "windows"]
-
-[build.linux]
-compiler = "gcc"
-cflags = ["-O2"]
-
-[build.windows]
-compiler = "x86_64-w64-mingw32-gcc"
+```
+hello/
+├── dcr.toml       # project config
+└── src/
+    └── main.c
 ```

-See [Cross-compilation guide](docs/dependencies-and-build/cross-compilation.md) for details.
+---

-## Configuration
-The main project file is `dcr.toml`.
-For multi-registry management, use `~/.dcr/config.toml`.
-
-Example `dcr.toml`:
+## dcr.toml Example

 ```toml
 [package]
 name = "hello"
 version = "0.1.0"
-type = "app" # or "lib", "none"

 [build]
 language = "c"
 standard = "c11"
 compiler = "clang"
-kind = "bin" # "bin", "staticlib", "sharedlib", "efi", "elf"
-# Optional platform hint
-# platform = "x86_64"
-# Optional custom flags
-cflags = ["-Wall", "-Wextra"]
-ldflags = ["-lm"]
-#
-# Optional include/exclude:
-# exclude = ["src/vendor", "src/legacy/**"]
-# include = ["src/boot/arch/**"]
-
-[toolchain]
-# Optional tool overrides:
-# cc = "clang"
-# cxx = "clang++"
-# as = "as"
-# ar = "ar"
-# ld = "ld"
-# uic = "uic"
-# moc = "moc"
-# rcc = "rcc"
+kind = "bin"

 [dependencies]
-my_lib = "path:./libs/my_lib"
-cool_lib = { git = "https://github.com/user/cool_lib", tag = "v1.0" }
 ```

-Workspace example:
-...
-[workspace]
-kernel = { path = "src/kernel", deps = ["core", "userspace"] }
-core = { path = "src/core", deps = ["userspace"] }
-userspace = { path = "src/userspace" }
+---
+
+## Base Commands
+
+| Command | Description |
+|---|---|
+| `dcr new <name>` | Create a new project |
+| `dcr init` | Initialize current directory |
+| `dcr build [--release]` | Build the project |
+| `dcr run [--release]` | Build and run |
+| `dcr clean` | Remove build artifacts |
+
+other in [docs/](docs/) and `dcr --help`
+
+---
+
+## Platforms
+
+<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
 ```

-Git and 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` or included header files change.
+<div align="center">

+GPL-3.0 — see [LICENSE](LICENSE)<br/>
+Made with ❤️ by [Dexoron](https://github.com/dexoron) and contributors.

-## Requirements
- Rust toolchain (`rustc`, `cargo`) - for building DCR from source
- C compiler (`clang`, `gcc`, or 'cl'(msvc))
-
-## Releases
-Releases are built automatically via GitHub Actions (`.github/workflows/release.yml`) when a tag matching `v*` is pushed.
-
-## License
-See `LICENSE`.
+</div>
--- a/TODO.md
+++ b/TODO.md
@@ -57,9 +57,11 @@ Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers
 ---

 **Currently in progress:**
+
 - ...

 **Completed in recent releases:**
+
 - Workspaces
 - Cross-compilation
 - IDE config generation (VS Code, CLion, compile_commands.json)
--- a/build.rs
+++ b/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}");
--- a/docs/configuration/build-section.md
+++ b/docs/configuration/build-section.md
@@ -31,7 +31,9 @@ kind = "bin"

 - `language` (string or array, required): `c`, `c++`, `cpp`, `cxx`, or `asm`.
  Mixed languages can be specified as an array, for example `["c", "c++", "asm"]`.
- `standard` (string, required): language standard passed to compiler.
+- `standard` (string, required): C language standard passed to compiler (e.g. `c11`, `c17`, `gnu11`).
+- `cxx_standard` (string, optional): C++ language standard passed to compiler for `.cpp`/`.cxx`/`.cc` files
+  (e.g. `c++17`, `gnu++17`, `c++20`). When set, overrides `standard` for C++ sources.
 - `compiler` (string, required): compiler command (for example `clang`, `gcc`, `cl`).
 - `kind` (string, required): `bin`, `staticlib`, `sharedlib`, `efi`, or `elf`.
 - `filename` (string, optional): custom output filename (without extension). Overrides `package.name` for the final artifact.
@@ -42,7 +44,9 @@ kind = "bin"
  When set, DCR automatically injects `--target=<value>` into `cflags` (useful for clang cross-compilation).
 - `platform` (string, optional): architecture hint for compiler (used for `-march` or `/arch`).
 - `cflags` (string array, optional): extra compile flags.
+  Supports variable substitution — see [Variable substitution](#variable-substitution) below.
 - `ldflags` (string array, optional): extra link flags.
+  Supports variable substitution — see [Variable substitution](#variable-substitution) below.
 - `ldscript` (string, optional): linker script path. Passed as `-T <path>` to the linker. Useful for bare-metal/embedded/freestanding targets.
 - `exclude` (string array, optional): paths or glob patterns to skip during source/header collection.
 - `include` (string array, optional): allowlist paths or globs that override `exclude`.
@@ -60,9 +64,30 @@ Notes for `exclude`/`include`:
 - Use `include` to re-allow nested paths, for example exclude `src/boot` but allow `src/boot/arch/**`.
 When using glob patterns in `exclude`, DCR converts them internally, so `exclude` globs still work as expected.

-### Build steps
+### Variable substitution

-Build steps run shell commands before compilation. Post steps run after linking.
+`cflags`, `ldflags`, and `include` directory entries support the same `{placeholder}` variables
+as build/post steps:
+
+| Variable | Description |
+|---|---|
+| `{profile}` | Build profile (`debug` / `release`) |
+| `{name}` | Package name |
+| `{version}` | Full package version (e.g. `0.2.1`) |
+| `{version_major}` | Major version number |
+| `{version_minor}` | Minor version number |
+| `{version_patch}` | Patch version number |
+| `{version_suffix}` | Version suffix (e.g. `-rc1`) |
+| `{version_suffix_dash}` | Suffix with leading dash (or empty) |
+
+Example:
+
+```toml
+[build]
+cflags = ['-DPROJECT_VERSION="{version}"', '-DVERSION_MAJOR={version_major}']
+```
+
+## Build steps

 ```toml
 [[build.steps]]
--- a/docs/configuration/package-section.md
+++ b/docs/configuration/package-section.md
@@ -4,9 +4,12 @@

 ```toml
 [package]
-name = "my-app"
-version = "0.1.0"
-type = "app"
+name        = "my-app"
+version     = "0.1.0"
+type        = "app"
+description = "My application"
+author      = "John Doe"
+license     = "MIT"
 ```

 ## Fields
@@ -14,6 +17,15 @@ type = "app"
 - `name` (string, required): used as output artifact base name.
 - `version` (string, required): used in `dcr.lock` project entry.
 - `type` (string, optional): project type (`app`, `lib`, `none`).
+- `description` (string, optional): human-readable project description.
+- `author` (string, optional): single author name.
+- `authors` (array of strings, optional): list of authors.
+- `license` (string, optional): project license identifier (e.g. `MIT`, `GPL-3.0-or-later`).
+- `homepage` (string, optional): project homepage URL.
+- `repository` (string, optional): source repository URL.
+- `readme` (string, optional): path to README file.
+- `keywords` (array of strings, optional): project keywords.
+- `categories` (array of strings, optional): project categories.

 ## Notes

--- a/docs/reference-and-help/config-reference.md
+++ b/docs/reference-and-help/config-reference.md
@@ -4,88 +4,131 @@

 ```toml
 [package]
-name = "string"      # required
-version = "string"   # required
+name        = "string"            # required
+version     = "string"            # required
+type        = "string"            # optional: "app", "lib", "none"
+description = "string"            # optional
+author      = "string"            # optional
+authors     = ["string", "..."]   # optional
+license     = "string"            # optional
+homepage    = "string"            # optional
+repository  = "string"            # optional
+readme      = "string"            # optional
+keywords    = ["string", "..."]   # optional
+categories  = ["string", "..."]   # optional

 [build]
-language = "c|c++|cpp|cxx|asm"     # required (string or array)
-standard = "string"            # required
-compiler = "string"            # required
-kind = "bin|staticlib|sharedlib"         # required
-filename = "string"            # optional (custom output name without extension)
-extension = "string"           # optional (custom extension without dot, e.g. "BIN")
-target = "string"              # optional
-platform = "string"            # optional
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
-ldscript = "string"            # optional (linker script, passed as -T<path>)
-exclude = ["string", "..."]    # optional
-include = ["string", "..."]    # optional
-roots = ["string", "..."]      # optional
-src_disable = false            # optional
-pkg_config = ["string", "..."] # optional
-generated = ["string", "..."]  # optional
-expect = ["string", "..."]     # optional
-clean = ["string", "..."]      # optional
+language     = "c|c++|cpp|cxx|asm"               # required (string or array)
+standard     = "string"                          # required (e.g. "c11", "gnu11")
+cxx_standard = "string"                          # optional (e.g. "c++17", "gnu++17")
+compiler     = "string"                          # required (e.g. "clang", "gcc")
+kind         = "bin|staticlib|sharedlib|efi|elf" # required
+target       = "string"                          # optional (cross-compilation target triple)
+platform     = "string"                          # optional (architecture hint, -march)
+type         = "string"                          # optional
+cflags       = ["string", "..."]                 # optional (supports {version} etc.)
+ldflags      = ["string", "..."]                 # optional (supports {version} etc.)
+ldscript     = "string"                          # optional (linker script path)
+exclude      = ["string", "..."]                 # optional (glob patterns)
+include      = ["string", "..."]                 # optional (allowlist + -I dirs)
+roots        = ["string", "..."]                 # optional (source roots)
+src_disable  = false                             # optional (disable default src/)
+pkg_config   = ["string", "..."]                 # optional (pkg-config packages)
+generated    = ["string", "..."]                 # optional (generated file patterns)
+expect       = ["string", "..."]                 # optional (expected artifact patterns)
+clean        = ["string", "..."]                 # optional (extra clean paths)
+targets      = ["string", "..."]                 # optional (build targets)
+filename     = "string"                          # optional (custom output name)
+extension    = "string"                          # optional (custom extension)
+inherit      = true                              # optional (inherit base settings)

 [[build.steps]]
-name = "string"
-in = "glob"
-out = "path or glob"
-cmd = "string"
+name = "string"    # required
+in   = "glob"      # required
+out  = "path"      # required
+cmd  = "string"    # required
+
+# Inline steps (equivalent to [[build.steps]])
+steps = [
+  { name = "string", in = "glob", out = "path", cmd = "string" },
+]

 [[build.post_steps]]
-name = "string"
-in = "glob"
-out = "path or glob"
-cmd = "string"
+name = "string"    # required
+in   = "glob"      # required (or "target/...")
+out  = "path"      # required
+cmd  = "string"    # required

-# Inline array form (equivalent to [[build.steps]] / [[build.post_steps]])
-steps = [
-  { name = "string", in = "glob", out = "path or glob", cmd = "string" },
-]
+# Inline post_steps (equivalent to [[build.post_steps]])
 post_steps = [
-    { name = "string", in = "glob", out = "path or glob", cmd = "string" },
+  { name = "string", in = "glob", out = "path", cmd = "string" },
 ]

+# Profile overrides (inherit all from [build])
 [build.debug]
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
+cflags  = ["string", "..."]  # optional
+ldflags = ["string", "..."]  # optional

 [build.release]
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
+cflags  = ["string", "..."]  # optional
+ldflags = ["string", "..."]  # optional
+
+# Target-specific overrides
+[build.linux]
+compiler = "string"
+cflags   = ["string", "..."]
+
+[build.windows]
+compiler = "string"
+
+# Target + profile override
+[build.linux.release]
+cflags = ["string", "..."]

 [toolchain]
-cc = "string"   # optional
-cxx = "string"  # optional
-as = "string"   # optional
-ar = "string"   # optional
-ld = "string"   # optional
-uic = "string"  # optional
-moc = "string"  # optional
-rcc = "string"  # optional
+cc  = "string"  # optional (C compiler override)
+cxx = "string"  # optional (C++ compiler override)
+as  = "string"  # optional (assembler override)
+ar  = "string"  # optional (archiver override)
+ld  = "string"  # optional (linker override)
+uic = "string"  # optional (Qt uic)
+moc = "string"  # optional (Qt moc)
+rcc = "string"  # optional (Qt rcc)

 [run]
-cmd = "string"  # optional
+cmd = "string"  # required for `dcr run`
+
+# Debug run variant
+[run.debug]
+cmd = "string"

 [workspace]
-name = { path = "string", deps = ["string", "..."] }
+[workspace.member_name]
+path = "string"             # required
+deps = ["string", "..."]    # optional

 [dependencies]
-name = {
-  path = "string",              # required for each dependency
-  include = ["string", "..."],  # optional
-  lib = ["string", "..."],      # optional
-  libs = ["string", "..."],     # optional
-}
+[dependencies.dep_name]
+path    = "string"          # local path
+# or
+version = "string"          # registry version
+# or
+git     = "string"          # git URL
+branch  = "string"          # optional (git branch)
+tag     = "string"          # optional (git tag)
+rev     = "string"          # optional (git commit)
+# common fields:
+include = ["string", "..."] # optional (include dirs)
+lib     = ["string", "..."] # optional (lib dirs)
+libs    = ["string", "..."] # optional (link libs)
+features = ["string", "..."] # optional (registry features)
 ```

 ## Validation rules

 - `[package]`, `[build]`, `[dependencies]` must exist.
 - Required string fields must be non-empty.
- `build.kind` must be `bin`, `staticlib`, or `sharedlib`.
+- `build.kind` must be `bin`, `staticlib`, `sharedlib`, `efi`, or `elf`.
 - Dependency fields `include/lib/libs` must be string arrays when provided.
 - `build.exclude`/`build.include` must be string arrays when provided.
 - `build.roots` must be a string array when provided.
--- a/packaging/aur/dcr-git
+++ b/packaging/aur/dcr-git
--- a/packaging/snap/snapcraft.yaml
+++ b/packaging/snap/snapcraft.yaml
@@ -0,0 +1,18 @@
+name: dcr
+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/
--- a/src/cli/add.rs
+++ b/src/cli/add.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::core::config::Config;
 use crate::core::deps::register;
 use crate::utils::fs::find_project_root;
--- a/src/cli/build.rs
+++ b/src/cli/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/>.
+
 use crate::cli::clean::clean;
 use crate::cli::flags::parse_build_run_flags;
 use crate::core::builder::common;
@@ -52,7 +69,9 @@ pub fn build(args: &[String]) -> i32 {

    if flags.target.is_none() {
        let config_path = root.join("dcr.toml");
-        if let Ok(config) = Config::open(config_path.to_str().unwrap()) {
+        if let Ok(config) = Config::open(config_path.to_str().unwrap())
+            && !config.is_workspace_only()
+        {
            let bt = get_build_string_with_profile(&config, "target", "debug");
            if !bt.is_empty() {
                flags.target = Some(bt);
@@ -83,6 +102,7 @@ pub fn build(args: &[String]) -> i32 {
            flags.target.as_deref(),
            flags.force,
            flags.verbose,
+            flags.workspace.as_deref(),
        )
    }) {
        Ok(()) => 0,
@@ -213,11 +233,18 @@ fn get_list_with_profile_and_target(
    // Custom from target/profile
    if let Some(val) = get_config_value_raw(config, "build", field, profile, target) {
        if let Some(_arr) = val.as_array() {
-            let custom = parse_string_array(&val, &format!("build.{field}"))?;
-            if inherit {
-                out.extend(custom);
-            } else {
-                out = custom;
+            let is_base = inherit
+                && config
+                    .get(&format!("build.{field}"))
+                    .map(|v| v == &val)
+                    .unwrap_or(false);
+            if !is_base {
+                let custom = parse_string_array(&val, &format!("build.{field}"))?;
+                if inherit {
+                    out.extend(custom);
+                } else {
+                    out = custom;
+                }
            }
        }
    } else if inherit {
@@ -348,8 +375,13 @@ fn get_build_steps_with_profile(
    get_build_steps(config, &format!("build.{field}"))
 }

-fn ensure_target_dirs(items: &[String], profile: &str, target_dir: Option<String>) {
-    if !items.contains(&"target".to_string()) {
+fn ensure_target_dirs(
+    items: &[String],
+    profile: &str,
+    target_dir: Option<String>,
+    skip_local_target: bool,
+) {
+    if !skip_local_target && !items.contains(&"target".to_string()) {
        let _ = fs::create_dir("./target");
    }
    if let Some(dir) = &target_dir {
@@ -390,8 +422,38 @@ fn build_from_root(
    target: Option<&str>,
    force: bool,
    verbose: bool,
+    workspace: Option<&str>,
 ) -> Result<(), String> {
    let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+
+    if config.is_workspace_only() {
+        let ws = parse_workspace(&config, profile, target, root)?
+            .ok_or_else(|| "Workspace root has no members defined".to_string())?;
+        let members: Vec<_> = if let Some(filter_name) = workspace {
+            ws.members
+                .into_iter()
+                .filter(|m| m.name == filter_name)
+                .collect()
+        } else {
+            ws.members
+        };
+        if members.is_empty() {
+            return Err("No matching workspace members to build".to_string());
+        }
+        for member in &members {
+            build_project_at(
+                &member.path,
+                profile,
+                target,
+                &[],
+                force,
+                verbose,
+                Some(root),
+            )?;
+        }
+        return Ok(());
+    }
+
    let project_name = get_config_str(&config, "package.name");
    let project_version = get_config_str(&config, "package.version");

@@ -430,20 +492,50 @@ fn build_from_root(
                )
            );
        }
-        if let Some(workspace) = parse_workspace(&config, profile, build_target.as_deref(), root)? {
-            build_workspace(&workspace, profile, build_target.as_deref(), force, verbose)?;
-            let excludes: Vec<std::path::PathBuf> =
-                workspace.members.iter().map(|m| m.path.clone()).collect();
+        if let Some(ws) = parse_workspace(&config, profile, build_target.as_deref(), root)? {
+            if let Some(filter_name) = workspace {
+                for member in ws.members.iter().filter(|m| m.name == filter_name) {
+                    build_project_at(
+                        &member.path,
+                        profile,
+                        build_target.as_deref(),
+                        &[],
+                        force,
+                        verbose,
+                        Some(root),
+                    )?;
+                }
+            } else {
+                build_workspace(
+                    &ws,
+                    profile,
+                    build_target.as_deref(),
+                    force,
+                    verbose,
+                    Some(root),
+                )?;
+                let excludes: Vec<std::path::PathBuf> =
+                    ws.members.iter().map(|m| m.path.clone()).collect();
+                build_project_at(
+                    root,
+                    profile,
+                    build_target.as_deref(),
+                    &excludes,
+                    force,
+                    verbose,
+                    None,
+                )?;
+            }
+        } else {
            build_project_at(
                root,
                profile,
                build_target.as_deref(),
-                &excludes,
+                &[],
                force,
                verbose,
+                None,
            )?;
-        } else {
-            build_project_at(root, profile, build_target.as_deref(), &[], force, verbose)?;
        }
    }
    let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -461,9 +553,18 @@ fn build_workspace(
    target: Option<&str>,
    force: bool,
    verbose: bool,
+    workspace_root: Option<&Path>,
 ) -> Result<(), String> {
    for member in &workspace.members {
-        build_project_at(&member.path, profile, target, &[], force, verbose)?;
+        build_project_at(
+            &member.path,
+            profile,
+            target,
+            &[],
+            force,
+            verbose,
+            workspace_root,
+        )?;
    }
    Ok(())
 }
@@ -475,6 +576,7 @@ fn build_project_at(
    exclude_dirs: &[std::path::PathBuf],
    force: bool,
    verbose: bool,
+    workspace_root: Option<&Path>,
 ) -> Result<(), String> {
    with_dir(project_root, || {
        check_interrupted()?;
@@ -482,7 +584,22 @@ fn build_project_at(
        if !items.contains(&"dcr.toml".to_string()) {
            return Err("dcr.toml file not found".to_string());
        }
-        let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+        let mut config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+        // Inherit build fields from workspace root if configured
+        if let Some(root) = workspace_root {
+            let has_inherit = config
+                .get("build.inherit")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+            if has_inherit {
+                let root_path = root.join("dcr.toml");
+                if root_path.is_file() {
+                    let parent_config =
+                        Config::open(&root_path.to_string_lossy()).map_err(|e| e.to_string())?;
+                    config.merge_parent(&parent_config);
+                }
+            }
+        }
        let project_name = get_config_str(&config, "package.name");
        let project_version = get_config_str(&config, "package.version");
        let build_target_config = get_build_string_with_profile(&config, "target", profile);
@@ -496,6 +613,8 @@ fn build_project_at(
        let build_language = get_language_with_profile(&config, profile)?;
        let build_standard =
            get_string_with_profile_and_target(&config, "standard", profile, build_target);
+        let build_cxx_standard =
+            get_string_with_profile_and_target(&config, "cxx_standard", profile, build_target);
        let build_kind = get_string_with_profile_and_target(&config, "kind", profile, build_target);
        let build_platform =
            get_string_with_profile_and_target(&config, "platform", profile, build_target);
@@ -522,17 +641,6 @@ fn build_project_at(
            .or_else(|| get_config_opt(&config, "toolchain.rcc"));
        let mut build_cflags =
            get_list_with_profile_and_target(&config, "cflags", profile, build_target)?;
-        if let Some(t) = build_target
-            && !t.trim().is_empty()
-        {
-            let target_flag = format!("--target={}", t.trim());
-            if !build_cflags
-                .iter()
-                .any(|f| f == &target_flag || f.starts_with("--target="))
-            {
-                build_cflags.insert(0, target_flag);
-            }
-        }
        let mut build_ldflags =
            get_list_with_profile_and_target(&config, "ldflags", profile, build_target)?;
        let build_ldscript =
@@ -569,11 +677,48 @@ fn build_project_at(
            tc_cxx.as_deref(),
            tc_as.as_deref(),
        );
+        if let Some(t) = build_target
+            && !t.trim().is_empty()
+            && resolved_compiler.to_lowercase().contains("clang")
+        {
+            let target_flag = format!("--target={}", t.trim());
+            if !build_cflags
+                .iter()
+                .any(|f| f == &target_flag || f.starts_with("--target="))
+            {
+                build_cflags.insert(0, target_flag);
+            }
+        }
        let resolved_linker = resolve_tool("DCR_LD", tc_ld.as_deref());
        let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref());

-        let target_dir = build_target.map(|t| format!("target/{t}/{profile}"));
-        ensure_target_dirs(&items, profile, target_dir);
+        let target_dir_binding = match workspace_root {
+            Some(root) => {
+                let target_str = build_target
+                    .map(normalize_target_os)
+                    .filter(|t| !t.is_empty());
+                let rel: PathBuf = match target_str {
+                    Some(ref t) => Path::new("target").join(t).join(profile),
+                    None => {
+                        let default_dir = if cfg!(target_os = "linux") {
+                            let arch = std::env::consts::ARCH;
+                            format!("{arch}-unknown-linux-gnu/{profile}")
+                        } else {
+                            profile.to_string()
+                        };
+                        Path::new("target").join(&default_dir)
+                    }
+                };
+                root.join(&rel).to_string_lossy().to_string()
+            }
+            None => normalize_target(build_target.unwrap_or(""), profile).unwrap_or_default(),
+        };
+        let target_dir = if target_dir_binding.is_empty() {
+            None
+        } else {
+            Some(target_dir_binding.clone())
+        };
+        ensure_target_dirs(&items, profile, target_dir, workspace_root.is_some());

        let deps_table = config.get("dependencies").and_then(|v| v.as_table());
        let resolved = resolve_deps(&config, profile, build_target, project_root)?;
@@ -609,7 +754,15 @@ fn build_project_at(
                                dep_root.display()
                            ));
                        }
-                        build_project_at(&dep_root, profile, build_target, &[], force, verbose)?;
+                        build_project_at(
+                            &dep_root,
+                            profile,
+                            build_target,
+                            &[],
+                            force,
+                            verbose,
+                            None,
+                        )?;
                        print!(
                            "\r{:100}\r       {} {} v{}",
                            "",
@@ -698,15 +851,35 @@ fn build_project_at(
            }
        }

-        let target_dir_binding = normalize_target(build_target.unwrap_or(""), profile);
+        let version_info = parse_version_info(&project_version);
+        let substitute = |s: &str| -> String {
+            s.replace("{profile}", profile)
+                .replace("{name}", &project_name)
+                .replace("{version}", &version_info.full)
+                .replace("{version_major}", &version_info.major)
+                .replace("{version_minor}", &version_info.minor)
+                .replace("{version_patch}", &version_info.patch)
+                .replace("{version_suffix}", &version_info.suffix)
+                .replace("{version_suffix_dash}", &version_info.suffix_dash)
+        };
+        let resolved_cflags: Vec<String> = resolved_cflags.iter().map(|f| substitute(f)).collect();
+        let modified_ldflags: Vec<String> =
+            resolved_ldflags.iter().map(|f| substitute(f)).collect();
+        let merged_include_dirs: Vec<String> =
+            merged_include_dirs.iter().map(|f| substitute(f)).collect();
        let ctx = BuildContext {
            profile,
            project_name: &project_name,
            compiler: &resolved_compiler,
            language: &build_language,
            standard: &build_standard,
+            cxx_standard: &build_cxx_standard,
            target: build_target,
-            target_dir: target_dir_binding.as_deref(),
+            target_dir: if target_dir_binding.is_empty() {
+                None
+            } else {
+                Some(target_dir_binding.as_str())
+            },
            kind: normalize_kind(&build_kind),
            platform: normalize_platform(&build_platform),
            linker: resolved_linker.as_deref(),
@@ -723,7 +896,7 @@ fn build_project_at(
            lib_dirs: &resolved.lib_dirs,
            libs: &resolved.libs,
            cflags: &resolved_cflags,
-            ldflags: &resolved_ldflags,
+            ldflags: &modified_ldflags,
            output_filename: if output_filename.is_empty() {
                None
            } else {
@@ -746,7 +919,6 @@ fn build_project_at(
        let tool_execs = resolve_toolchain_execs(&tc_uic, &tc_moc, &tc_rcc, &pkg_configs);
        let step_flags =
            build_step_flags(&resolved_cflags, &resolved.include_dirs, &resolved_compiler);
-        let version_info = parse_version_info(&project_version);
        let step_vars = StepVars {
            profile,
            version: &version_info.full,
--- a/src/cli/clean.rs
+++ b/src/cli/clean.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::config::flags;
 use crate::core::config::Config;
 use crate::core::workspace::parse_workspace;
--- a/src/cli/flag_update.rs
+++ b/src/cli/flag_update.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::log::{error, warn};
 use reqwest::blocking::Client;
 use serde::Deserialize;
--- a/src/cli/flags.rs
+++ b/src/cli/flags.rs
@@ -1,9 +1,27 @@
+// 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,
@@ -12,6 +30,7 @@ pub struct BuildRunFlags {
 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;
@@ -35,6 +54,15 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
            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());
@@ -59,6 +87,7 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
    Ok(BuildRunFlags {
        profile,
        target,
+        workspace,
        force,
        clean,
        verbose,
--- a/src/cli/gen.rs
+++ b/src/cli/gen.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::core::builder::BuildContext;
 use crate::core::builder::collect_sources;
 use crate::core::builder::common;
@@ -154,6 +171,7 @@ pub struct ProjectInfo {
    pub profile: String,
    pub language: String,
    pub standard: String,
+    pub cxx_standard: String,
    pub compiler: String,
    pub kind: String,
    pub sources: Vec<String>,
@@ -211,6 +229,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
    let version = get_config_str(&config, "package.version");
    let language = get_language_with_profile_or_default(&config, profile);
    let standard = get_string_with_profile(&config, "standard", profile);
+    let cxx_standard = get_string_with_profile(&config, "cxx_standard", profile);
    let compiler_s = get_string_with_profile(&config, "compiler", profile);
    let kind = get_string_with_profile(&config, "kind", profile);
    let build_target = get_string_with_profile(&config, "target", profile);
@@ -322,6 +341,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
        compiler: &resolved_compiler,
        language: &language,
        standard: &standard,
+        cxx_standard: &cxx_standard,
        target: Some(build_target.as_str()),
        target_dir: target_dir_binding.as_deref(),
        kind: normalize_kind(&kind),
@@ -364,6 +384,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
        profile: profile.to_string(),
        language,
        standard,
+        cxx_standard,
        compiler: resolved_compiler,
        kind: normalize_kind(&kind).to_string(),
        sources: abs_sources,
@@ -454,6 +475,10 @@ fn project_info_to_json(info: &ProjectInfo) -> String {
        "    \"standard\": {},\n",
        json_str(&info.standard)
    ));
+    out.push_str(&format!(
+        "    \"cxx_standard\": {},\n",
+        json_str(&info.cxx_standard)
+    ));
    out.push_str(&format!(
        "    \"compiler\": {},\n",
        json_str(&info.compiler)
@@ -558,6 +583,13 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
    };
    cmd.push(compiler.to_string());
    cmd.push("-c".to_string());
+
+    // ASM x flag — must be before source file
+    if let Some(flag) = asm_lang_flag(source) {
+        cmd.push("-x".to_string());
+        cmd.push(flag.to_string());
+    }
+
    cmd.push(source.to_string());

    // Object path (for -o, approximate — not critical for IntelliSense)
@@ -578,15 +610,18 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
        cmd.push("-fPIC".to_string());
    }

-    // ASM x flag
-    if let Some(flag) = asm_lang_flag(source) {
-        cmd.push("-x".to_string());
-        cmd.push(flag.to_string());
-    }
-
    // -std=
    if !info.standard.is_empty() && info.language.to_lowercase() != "asm" {
-        cmd.push(format!("-std={}", info.standard));
+        let ext = Path::new(source)
+            .extension()
+            .and_then(|e| e.to_str())
+            .unwrap_or("");
+        let is_cpp = matches!(ext, "cpp" | "cxx" | "cc");
+        if is_cpp && !info.cxx_standard.is_empty() {
+            cmd.push(format!("-std={}", info.cxx_standard));
+        } else if !is_cpp {
+            cmd.push(format!("-std={}", info.standard));
+        }
    }

    // Default profile flags (mirrors unix_cc.rs defaults)
--- a/src/cli/help.rs
+++ b/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 {
--- a/src/cli/init.rs
+++ b/src/cli/init.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::config::FILE_MAIN_C;
 use crate::core::config::Config;
 use crate::utils::fs::check_dir;
--- a/src/cli/mod.rs
+++ b/src/cli/mod.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 mod add;
 pub mod build;
 pub mod clean;
--- a/src/cli/new.rs
+++ b/src/cli/new.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::config::FILE_MAIN_C;
 use crate::core::config::Config;
 use crate::utils::fs::check_dir;
--- a/src/cli/run.rs
+++ b/src/cli/run.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::cli::build::build;
 use crate::cli::flags::parse_build_run_flags;
 use crate::core::config::Config;
@@ -7,6 +24,7 @@ use crate::utils::fs::find_project_root;
 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(
@@ -65,18 +83,82 @@ 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("");

-    let mut flags = match parse_build_run_flags(args) {
-        Ok(v) => v,
-        Err(_) => return 1,
-    };
-
    // If no target specified, use default host target for target-specific config
-    if flags.target.is_none() {
+    let mut target = flags.target.clone();
+    if target.is_none() {
        let default_target = if cfg!(target_os = "linux") {
            "x86_64-unknown-linux-gnu"
        } else if cfg!(target_os = "macos") {
@@ -86,7 +168,7 @@ pub fn run(args: &[String]) -> i32 {
        } else {
            "unknown"
        };
-        flags.target = Some(default_target.to_string());
+        target = Some(default_target.to_string());
    }

    let build_kind = config
@@ -95,25 +177,30 @@ pub fn run(args: &[String]) -> i32 {
        .or_else(|| config.get("build.kind").and_then(|v| v.as_str()))
        .unwrap_or("");

-    let normalized_target_dir = flags
-        .target
-        .as_ref()
-        .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile));
+    let normalized_target_dir = 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 run_cmd = get_run_cmd(&config, &flags.profile, flags.target.as_deref(), version);
+    let run_cmd = get_run_cmd(&config, &flags.profile, target.as_deref(), version);

    let kind = build_kind.trim();
    if run_cmd.is_none()
        && (kind == "staticlib" || kind == "sharedlib" || kind == "efi" || kind == "elf")
    {
-        error("Cannot run library build");
-        return 1;
+        return Err("Cannot run library build".to_string());
    }
-    let build_status = build(args);
+
+    let build_status = build(&args_for_build(flags));
    let bin_path = crate::platform::bin_path(
        &flags.profile,
        project_name,
@@ -123,15 +210,15 @@ pub fn run(args: &[String]) -> i32 {
        if let Some(cmd) = run_cmd {
            println!("\n    {} {}", colored("Running", BOLD_GREEN), cmd);
            println!("--------------------------------");
-            return run_shell(&cmd);
+            return Ok(run_shell(&cmd));
        }
        println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
        println!("--------------------------------");
-        return run_binary(
+        return Ok(run_binary(
            project_name,
            &flags.profile,
            normalized_target_dir.as_deref(),
-        );
+        ));
    }

    let fallback_code = if let Some(cmd) = run_cmd {
@@ -144,11 +231,27 @@ pub fn run(args: &[String]) -> i32 {
        )
    };
    if fallback_code != 1 {
-        return fallback_code;
+        return Ok(fallback_code);
    }

-    error("Fix errors in the code to run the project");
-    1
+    Err("Fix errors in the code to run the project".to_string())
+}
+
+fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> Vec<String> {
+    let mut args = Vec::new();
+    args.push(format!("--{}", flags.profile));
+    if let Some(ref target) = flags.target {
+        args.push("--target".to_string());
+        args.push(target.clone());
+    }
+    if let Some(ref name) = flags.workspace {
+        args.push("--workspace".to_string());
+        args.push(name.clone());
+    }
+    if flags.verbose {
+        args.push("--verbose".to_string());
+    }
+    args
 }

 fn run_shell(cmd: &str) -> i32 {
--- a/src/cli/setup.rs
+++ b/src/cli/setup.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 fn setup(_args: &[String]) -> i32 {
    println!("Setting up DCR registries...");
    match crate::core::registry::RegistryManager::load() {
--- a/src/cli/test.rs
+++ b/src/cli/test.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::cli::build;
 use crate::config::{FILE_DCR_TEST_H, FILE_TEST_C, flags};
 use crate::core::config::Config;
--- a/src/cli/tree.rs
+++ b/src/cli/tree.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::core::config::Config;
 use crate::utils::log::error;
 use crate::utils::text::{BOLD_CYAN, printc};
--- a/src/config.rs
+++ b/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>

--- a/src/core/builder/common.rs
+++ b/src/core/builder/common.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 std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -245,7 +262,22 @@ pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
        stripped.to_path_buf()
    };
    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
+    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()
 }

@@ -362,28 +394,28 @@ mod tests {
    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.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.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.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.obj");
+        assert_eq!(result, "target/debug/obj/main.c.obj");
    }

    #[test]
--- a/src/core/builder/gas.rs
+++ b/src/core/builder/gas.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::core::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -8,7 +25,7 @@ use std::time::Instant;

 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    let lang = ctx.language.to_lowercase();
-    if lang.split('+').any(|p| p.trim() != "asm") {
+    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() {
--- a/src/core/builder/mod.rs
+++ b/src/core/builder/mod.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 mod common;
 pub mod gas;
 pub mod msvc;
@@ -10,7 +27,7 @@ pub struct BuildContext<'a> {
    pub compiler: &'a str,
    pub language: &'a str,
    pub standard: &'a str,
-    #[allow(dead_code)]
+    pub cxx_standard: &'a str,
    pub target: Option<&'a str>,
    pub target_dir: Option<&'a str>,
    pub kind: &'a str,
--- a/src/core/builder/msvc.rs
+++ b/src/core/builder/msvc.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::core::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -127,8 +144,8 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>

 fn source_extensions(language: &str) -> Vec<&str> {
    let mut out = Vec::new();
-    for part in language.split('+') {
-        let lang = part.trim().to_lowercase();
+    for part in language.split(',').map(|s| s.trim()) {
+        let lang = part.to_lowercase();
        match lang.as_str() {
            "c" => out.extend(["c"]),
            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
@@ -226,18 +243,26 @@ fn build_object(
    let mut cmd = Command::new(compiler);
    cmd.arg("/nologo");

-    match ctx.language.to_lowercase().as_str() {
-        "c" => {
-            cmd.arg("/TC");
-        }
-        "c++" | "cpp" | "cxx" => {
-            cmd.arg("/TP");
-        }
-        _ => return Err("Unsupported language".to_string()),
+    let ext = Path::new(source)
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("");
+    let is_cpp = matches!(ext, "cpp" | "cxx" | "cc");
+    if is_cpp {
+        cmd.arg("/TP");
+    } else {
+        cmd.arg("/TC");
    }

-    if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
-        let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
+    let std_val = if is_cpp && !ctx.cxx_standard.is_empty() {
+        ctx.cxx_standard
+    } else if !is_cpp && !ctx.standard.is_empty() {
+        ctx.standard
+    } else {
+        ""
+    };
+    if !std_val.is_empty() {
+        let std_flag = msvc_standard_flag(if is_cpp { "c++" } else { "c" }, std_val)?;
        cmd.arg(std_flag);
    }

--- a/src/core/builder/nasm.rs
+++ b/src/core/builder/nasm.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::core::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -8,7 +25,7 @@ use std::time::Instant;

 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
    let lang = ctx.language.to_lowercase();
-    if lang.split('+').any(|p| p.trim() != "asm") {
+    if lang.split(',').any(|p| p.trim() != "asm") {
        return Err("NASM backend requires build.language = \"asm\"".to_string());
    }
    let assembler = if ctx.compiler.is_empty() {
--- a/src/core/builder/unix_cc.rs
+++ b/src/core/builder/unix_cc.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::core::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -116,8 +133,8 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>

 fn source_extensions(language: &str) -> Vec<&str> {
    let mut out = Vec::new();
-    for part in language.split('+') {
-        let lang = part.trim().to_lowercase();
+    for part in language.split(',').map(|s| s.trim()) {
+        let lang = part.to_lowercase();
        match lang.as_str() {
            "c" => out.extend(["c"]),
            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
@@ -193,16 +210,18 @@ fn build_object(
    }

    let mut cmd = Command::new(compiler);
-    cmd.arg("-c").arg(source).arg("-o").arg(obj_path);
-
-    if ctx.kind == "sharedlib" {
-        cmd.arg("-fPIC");
-    }
+    cmd.arg("-c");

    if let Some(flag) = asm_lang_flag(source) {
        cmd.arg("-x").arg(flag);
    }

+    cmd.arg(source).arg("-o").arg(obj_path);
+
+    if ctx.kind == "sharedlib" {
+        cmd.arg("-fPIC");
+    }
+
    if let Some(platform) = ctx.platform
        && !platform.trim().is_empty()
    {
@@ -210,7 +229,16 @@ fn build_object(
    }

    if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
-        cmd.arg(format!("-std={}", ctx.standard));
+        let ext = Path::new(source)
+            .extension()
+            .and_then(|e| e.to_str())
+            .unwrap_or("");
+        let is_cpp = matches!(ext, "cpp" | "cxx" | "cc");
+        if is_cpp && !ctx.cxx_standard.is_empty() {
+            cmd.arg(format!("-std={}", ctx.cxx_standard));
+        } else if !is_cpp {
+            cmd.arg(format!("-std={}", ctx.standard));
+        }
    }

    let use_dcr_defaults = ctx.cflags.is_empty() && !is_bare_metal_target(ctx.target);
--- a/src/core/config.rs
+++ b/src/core/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/>.
+
 use serde::Deserialize;
 use std::collections::BTreeMap;
 use std::fs;
@@ -60,8 +77,10 @@ pub struct Config {
 #[allow(dead_code)]
 #[derive(Debug, Clone, Deserialize)]
 pub struct DcrConfig {
-    pub package: PackageConfig,
-    pub build: BuildConfig,
+    #[serde(default)]
+    pub package: Option<PackageConfig>,
+    #[serde(default)]
+    pub build: Option<BuildConfig>,
    #[serde(default)]
    pub dependencies: BTreeMap<String, DependencyConfig>,
    #[serde(default)]
@@ -83,6 +102,8 @@ pub struct PackageConfig {
 pub struct BuildConfig {
    pub language: LanguageConfig,
    pub standard: String,
+    #[serde(default)]
+    pub cxx_standard: Option<String>,
    pub compiler: String,
    #[serde(default)]
    pub kind: Option<String>,
@@ -104,6 +125,8 @@ pub struct BuildConfig {
    pub clean: Vec<String>,
    #[serde(default)]
    pub src_disable: Option<bool>,
+    #[serde(default)]
+    pub workspace_only: bool,
 }

 #[derive(Debug, Clone, Deserialize)]
@@ -182,13 +205,100 @@ impl Config {
    }

    #[allow(dead_code)]
-    pub fn package(&self) -> &PackageConfig {
-        &self.typed.package
+    pub fn package(&self) -> Option<&PackageConfig> {
+        self.typed.package.as_ref()
    }

    #[allow(dead_code)]
-    pub fn build_config(&self) -> &BuildConfig {
-        &self.typed.build
+    pub fn build_config(&self) -> Option<&BuildConfig> {
+        self.typed.build.as_ref()
+    }
+
+    pub fn is_workspace_only(&self) -> bool {
+        self.typed
+            .build
+            .as_ref()
+            .map(|b| b.workspace_only)
+            .unwrap_or(false)
+            && !self.typed.workspace.is_empty()
+    }
+
+    /// Merge build fields from parent config into self where self has empty/default values.
+    /// Used for workspace member inheritance (build.inherit = true).
+    pub fn merge_parent(&mut self, parent: &Config) {
+        let fields: &[&str] = &[
+            "language",
+            "standard",
+            "cxx_standard",
+            "compiler",
+            "kind",
+            "target",
+            "platform",
+            "cflags",
+            "ldflags",
+            "exclude",
+            "include",
+            "roots",
+            "clean",
+            "src_disable",
+        ];
+        let parent_build = match parent.data.get("build").and_then(|v| v.as_table()) {
+            Some(t) => t.clone(),
+            None => return,
+        };
+
+        let self_build = self
+            .data
+            .get("build")
+            .and_then(|v| v.as_table())
+            .cloned()
+            .unwrap_or_default();
+
+        let mut changes: Vec<(String, toml::Value)> = Vec::new();
+
+        for field in fields {
+            let val = match parent_build.get(*field) {
+                Some(v) => v,
+                None => continue,
+            };
+
+            let self_val = self_build.get(*field);
+            let should_inherit = match val {
+                toml::Value::Array(_) => self_val.is_none(),
+                toml::Value::String(_) => self_val
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.trim().is_empty())
+                    .unwrap_or(true),
+                _ => self_val.is_none(),
+            };
+            if should_inherit {
+                changes.push((field.to_string(), val.clone()));
+            }
+        }
+
+        if changes.is_empty() {
+            return;
+        }
+
+        if !self.data.is_table() {
+            let mut m = Map::new();
+            m.insert("build".to_string(), toml::Value::Table(Map::new()));
+            self.data = toml::Value::Table(m);
+        }
+
+        let tbl = self.data.as_table_mut().unwrap();
+        let build_tbl = tbl
+            .entry("build".to_string())
+            .or_insert_with(|| toml::Value::Table(Map::new()));
+        if let Some(build_tbl) = build_tbl.as_table_mut() {
+            for (key, val) in changes {
+                build_tbl.entry(key).or_insert(val);
+            }
+        }
+
+        if let Ok(typed) = parse_typed_config(&self.data) {
+            self.typed = typed;
+        }
    }

    pub fn get(&self, key: &str) -> Option<&Value> {
@@ -210,15 +320,29 @@ impl Config {
    }

    pub fn validate(&self) -> Result<(), ConfigError> {
-        if self.typed.package.name.trim().is_empty() {
+        if self.is_workspace_only() {
+            return self.validate_workspace();
+        }
+
+        let pkg =
+            self.typed.package.as_ref().ok_or_else(|| {
+                ConfigError::Invalid("missing [package] section (required)".into())
+            })?;
+        let build = self
+            .typed
+            .build
+            .as_ref()
+            .ok_or_else(|| ConfigError::Invalid("missing [build] section (required)".into()))?;
+
+        if pkg.name.trim().is_empty() {
            return Err(ConfigError::Invalid("package.name is empty".into()));
        }
-        if self.typed.package.version.trim().is_empty() {
+        if pkg.version.trim().is_empty() {
            return Err(ConfigError::Invalid("package.version is empty".into()));
        }
-        validate_package_name(&self.typed.package.name)?;
+        validate_package_name(&pkg.name)?;

-        if let Some(pkg_type) = &self.typed.package.pkg_type {
+        if let Some(pkg_type) = &pkg.pkg_type {
            let pkg_type = pkg_type.trim();
            if !pkg_type.is_empty() && pkg_type != "lib" && pkg_type != "app" && pkg_type != "none"
            {
@@ -228,32 +352,32 @@ impl Config {
            }
        }

-        validate_language_config(&self.typed.build.language, "build.language")?;
-        if self.typed.build.standard.trim().is_empty() {
+        validate_language_config(&build.language, "build.language")?;
+        if build.standard.trim().is_empty() {
            return Err(ConfigError::Invalid("build.standard is empty".into()));
        }
-        if self.typed.build.compiler.trim().is_empty() {
+        if build.compiler.trim().is_empty() {
            return Err(ConfigError::Invalid("build.compiler is empty".into()));
        }
-        if let Some(platform) = &self.typed.build.platform
+        if let Some(platform) = &build.platform
            && platform.trim().is_empty()
        {
            return Err(ConfigError::Invalid("build.platform is empty".into()));
        }
        validate_toolchain(self.typed.toolchain.as_ref())?;
-        if let Some(kind) = &self.typed.build.kind {
+        if let Some(kind) = &build.kind {
            let kind = kind.trim();
            if !kind.is_empty() && !VALID_KINDS.contains(&kind) {
                return Err(ConfigError::Invalid("build.kind is invalid".into()));
            }
        }
-        validate_string_list(&self.typed.build.exclude, "build.exclude")?;
-        validate_string_list(&self.typed.build.include, "build.include")?;
-        validate_string_list(&self.typed.build.roots, "build.roots")?;
-        validate_string_list(&self.typed.build.clean, "build.clean")?;
-        validate_string_list(&self.typed.build.cflags, "build.cflags")?;
-        validate_string_list(&self.typed.build.ldflags, "build.ldflags")?;
-        if let Some(target) = &self.typed.build.target {
+        validate_string_list(&build.exclude, "build.exclude")?;
+        validate_string_list(&build.include, "build.include")?;
+        validate_string_list(&build.roots, "build.roots")?;
+        validate_string_list(&build.clean, "build.clean")?;
+        validate_string_list(&build.cflags, "build.cflags")?;
+        validate_string_list(&build.ldflags, "build.ldflags")?;
+        if let Some(target) = &build.target {
            validate_non_empty_string(target, "build.target")?;
        }
        for profile in ["release", "debug"] {
@@ -535,7 +659,10 @@ fn default_toml() -> Result<Value, ConfigError> {
    package.insert("type".to_string(), Value::String("none".to_string()));
    package.insert("description".to_string(), Value::String("".to_string()));
    package.insert("author".to_string(), Value::String("".to_string()));
-    package.insert("license".to_string(), Value::String("MIT".to_string()));
+    package.insert(
+        "license".to_string(),
+        Value::String("GPL-3.0-or-later".to_string()),
+    );

    let mut build = Map::new();
    build.insert(
@@ -802,10 +929,10 @@ mod tests {
            "[package]\nname = \"typed\"\nversion = \"1.2.3\"\ntype = \"lib\"\n\n[build]\nlanguage = [\"c\", \"c++\"]\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"staticlib\"\ncflags = [\"-Wall\"]\n\n[dependencies]\nfoo = \"1.0.0\"\n",
        );
        let config = Config::open(&path.to_string_lossy()).unwrap();
-        assert_eq!(config.package().name, "typed");
-        assert_eq!(config.typed().package.version, "1.2.3");
-        assert_eq!(config.build_config().compiler, "clang");
-        assert_eq!(config.build_config().cflags, ["-Wall"]);
+        assert_eq!(config.package().unwrap().name, "typed");
+        assert_eq!(config.typed().package.as_ref().unwrap().version, "1.2.3");
+        assert_eq!(config.build_config().unwrap().compiler, "clang");
+        assert_eq!(config.build_config().unwrap().cflags, ["-Wall"]);
        assert!(config.typed().dependencies.contains_key("foo"));
    }

--- a/src/core/deps/common.rs
+++ b/src/core/deps/common.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/>.
+
 #[allow(dead_code)]
 use std::fs;
 use std::path::{Path, PathBuf};
--- a/src/core/deps/git.rs
+++ b/src/core/deps/git.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 std::path::Path;

 #[allow(dead_code)]
--- a/src/core/deps/lock.rs
+++ b/src/core/deps/lock.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 sha2::{Digest, Sha256};
 use std::fs;
 use std::path::Path;
--- a/src/core/deps/mod.rs
+++ b/src/core/deps/mod.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 mod common;
 pub mod git;
 pub mod lock;
--- a/src/core/deps/register.rs
+++ b/src/core/deps/register.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 serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use std::fs;
--- a/src/core/mod.rs
+++ b/src/core/mod.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 mod builder;
 pub mod config;
 pub mod deps;
--- a/src/core/registry.rs
+++ b/src/core/registry.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 serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
--- a/src/core/runner.rs
+++ b/src/core/runner.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::platform;
 use std::path::Path;
 use std::process::Command;
--- a/src/core/workspace.rs
+++ b/src/core/workspace.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::core::config::Config;
 use crate::utils::build::normalize_target_os;
 use std::collections::{HashMap, HashSet};
@@ -9,6 +26,7 @@ pub struct WorkspaceMember {
    pub name: String,
    pub path: PathBuf,
    pub deps: Vec<String>,
+    pub main: bool,
 }

 #[derive(Debug, Clone)]
@@ -16,6 +34,15 @@ pub struct Workspace {
    pub members: Vec<WorkspaceMember>,
 }

+impl Workspace {
+    pub fn main_member(&self) -> Option<&WorkspaceMember> {
+        self.members
+            .iter()
+            .find(|m| m.main)
+            .or_else(|| self.members.first())
+    }
+}
+
 pub fn parse_workspace(
    config: &Config,
    profile: &str,
@@ -68,6 +95,7 @@ pub fn parse_workspace(
            name: name.to_string(),
            path,
            deps,
+            main: tbl.get("main").and_then(|v| v.as_bool()).unwrap_or(false),
        });
    }

--- a/src/main.rs
+++ b/src/main.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::log::error;
 mod cli;
 mod config;
--- a/src/platform/linux.rs
+++ b/src/platform/linux.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 fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
--- a/src/platform/macos.rs
+++ b/src/platform/macos.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 fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
--- a/src/platform/mod.rs
+++ b/src/platform/mod.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/>.
+
 #[cfg(target_os = "linux")]
 pub mod linux;
 #[cfg(target_os = "macos")]
--- a/src/platform/windows.rs
+++ b/src/platform/windows.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 fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
--- a/src/utils/build.rs
+++ b/src/utils/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/>.
+
 use crate::core::config::Config;
 use crate::utils::log::warn;

@@ -173,7 +190,7 @@ pub fn parse_language_value(value: &toml::Value, key: &str) -> Result<String, St
    if parts.is_empty() {
        return Err(format!("{key} is empty"));
    }
-    Ok(parts.join("+"))
+    Ok(parts.join(","))
 }

 pub fn resolve_compiler(
@@ -241,7 +258,7 @@ fn toolchain_override_compiler(

 pub fn primary_language(language: &str) -> String {
    let parts: Vec<String> = language
-        .split('+')
+        .split(',')
        .map(|p| p.trim().to_lowercase())
        .filter(|p| !p.is_empty())
        .collect();
--- a/src/utils/fs.rs
+++ b/src/utils/fs.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 std::io;
 use std::path::{Path, PathBuf};

--- a/src/utils/log.rs
+++ b/src/utils/log.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, colored};

 #[allow(dead_code)]
--- a/src/utils/mod.rs
+++ b/src/utils/mod.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 mod build;
 pub mod fs;
 pub mod log;
--- a/src/utils/text.rs
+++ b/src/utils/text.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/>.
+
 #[allow(dead_code)]
 pub const RESET: &str = "\x1b[0m";

--- a/tests/cli_basic.rs
+++ b/tests/cli_basic.rs
@@ -198,18 +198,6 @@ fn workspace_build_and_clean_all() {
        "workspace clean --all --release should succeed"
    );

-    for (name, _) in &members {
-        let member = root.join("src").join(name);
-        let target_dir = "target/x86_64-unknown-linux-gnu";
-        assert!(
-            !member.join(target_dir).join("release").exists(),
-            "member target/x86_64-unknown-linux-gnu/release should be removed"
-        );
-        assert!(
-            member.join(target_dir).join("debug").exists(),
-            "member target/x86_64-unknown-linux-gnu/debug should remain"
-        );
-    }
    let target_dir = "target/x86_64-unknown-linux-gnu";
    assert!(
        !root.join(target_dir).join("release").exists(),
--- a/tests/cli_errors.rs
+++ b/tests/cli_errors.rs
@@ -280,8 +280,11 @@ fn build_release_profile() {
    let out = run_dcr_env(&["build", "--release"], &dir, &envs);
    assert!(out.status.success(), "release build should succeed");
    assert!(
-        dir.join("target").join("release").is_dir(),
-        "target/release should exist"
+        dir.join("target")
+            .join("x86_64-unknown-linux-gnu")
+            .join("release")
+            .is_dir(),
+        "target/x86_64-unknown-linux-gnu/release should exist"
    );
 }
Author	SHA1	Message	Date
Dexoron	78160e2bb9	feat: set MAKE environment variable for NetBSD build process	2026-05-28 16:55:51 +08:00
Dexoron	7f9cd3d643	fix: correct path for Snap package output in release workflow	2026-05-28 16:53:14 +08:00
Dexoron	4d1bd1dbdc	feat: update snap packaging directory structure and fix NetBSD package installation command	2026-05-28 16:43:27 +08:00
Dexoron	7bc571ea27	feat: update snap packaging paths and improve asset configuration in Cargo.toml	2026-05-28 16:10:28 +08:00
Dexoron	f431c3d018	feat: update package metadata for RPM generation in Cargo.toml and fix snap package path	2026-05-28 15:34:24 +08:00
Dexoron	9fd1652ebb	chore: release v0.6.9	2026-05-28 15:18:03 +08:00
Dexoron	c59d6de54f	feat: enhance release workflow with Arch Linux native build and AUR update options	2026-05-28 00:13:01 +08:00
Dexoron	73b6ce903e	feat: add Arch Linux native package build process to release workflow	2026-05-28 00:07:36 +08:00
Dexoron	e97b9b6e00	feat: enhance package database update process with checks for existing files	2026-05-27 23:58:53 +08:00
Dexoron	12d1bc5111	feat: add Dexoron Packages Index workflow for automatic package updates	2026-05-27 23:55:11 +08:00
Dexoron	8c9dd39503	feat: update version to 0.6.9 and add packaging for Linux and BSD - Bump version from 0.6.8 to 0.6.9 in Cargo.toml and Cargo.lock. - Enhance GitHub Actions workflow to build and publish .deb, .rpm, and Snap packages. - Implement AUR publishing for both dcr and dcr-bin packages. - Add support for workspace-only projects in the build system. - Introduce new `workspace` flag for build and run commands. - Create snapcraft.yaml for Snap package configuration. - Update build.rs and related files to handle workspace members and inheritance. - Modify config handling to support optional package and build configurations.	2026-05-27 23:14:49 +08:00
Dexoron	e3c35793ec	feat: enhance FreeBSD, OpenBSD, and NetBSD build processes in release workflow	2026-05-27 20:42:30 +08:00
Dexoron	a55d64c5ff	feat: bump version to 0.6.8 in Cargo files	2026-05-27 20:18:49 +08:00
Dexoron	acdd1cc175	feat: enhance build configuration with C++ standard support and variable substitution - Added `cxx_standard` field to the build configuration for specifying C++ standards. - Updated documentation to reflect new `cxx_standard` and variable substitution capabilities in `cflags`, `ldflags`, and `include`. - Implemented logic to handle C++ standard flags in the build process. - Modified object file naming to include source file extensions. - Updated various builder modules to support new language parsing logic. - Introduced issue and feature request templates for better community engagement.	2026-05-27 20:04:01 +08:00
Dexoron	b5bbdb929b	Add GPL-3.0-or-later license headers to source files - Updated all relevant source files to include the new license header. - Changed the default license in the configuration from MIT to GPL-3.0-or-later.	2026-05-27 17:34:56 +08:00
Dexoron	29120e0e29	feat: add Homebrew tap update workflow with asset download and formula generation	2026-05-26 20:20:39 +08:00
Dexoron	b66c846956	feat: improve release workflow with enhanced tag handling and clearer input descriptions	2026-05-26 19:39:35 +08:00
Dexoron	2a9c918711	fix: add missing package metadata including description, license, and repository URL	2026-05-26 19:36:39 +08:00
Dexoron	2af3baf4bb	feat: enhance release workflow with additional input options and build configurations for Linux, macOS, and Windows	2026-05-26 19:16:09 +08:00