Compare commits

..

1 Commits

Author SHA1 Message Date
5b29419c2d
Update on project status and team changes
All checks were successful
Builds / ExectOS WebSite (push) Successful in 59s
2024-10-06 16:52:30 +02:00
11 changed files with 27 additions and 251 deletions

View File

@ -4,6 +4,7 @@ title = "ExectOS Operating System"
theme = "exectos"
languageCode = "en-us"
defaultContentLanguage = "en"
paginate = 10
[menu]

View File

@ -1,28 +0,0 @@
+++
title = 'AI-Assisted Contributions'
date = 2025-07-17T19:44:12+02:00
+++
This project includes content and code that has been partially created or assisted by artificial intelligence (AI) tools.
### Tools We Use
We actively use the following AI tools to support development and documentation workflows:
* **ChatGPT**: for generating and reviewing code, technical writing, and problem-solving assistance.
* **Gemini Assistant**: integrated with VS Code, used for code suggestions and refactoring.
* **Windsurf**: VS Code extension that helps streamline repetitive coding tasks.
We are also experimenting with other AI-based tools to evaluate their usefulness in different areas of the project.
### Human Review
All AI-assisted contributions are reviewed and validated by human developers before being committed to the project. We ensure
that any code, documentation, or design produced with AI meets our quality and security standards.
### Why Use AI?
Using AI tools allows us to:
* Accelerate development and reduce boilerplate
* Improve consistency in code and documentation
* Explore alternative solutions more efficiently
* Focus developer time on complex or creative tasks
### Transparency & Ethics
We are committed to transparent and responsible use of AI. Our goal is to ensure that AI supports - but never replaces -
thoughtful human contribution. If you have any questions or concerns about the role of AI in this project, please open an
issue or contact the maintainers.

View File

@ -14,5 +14,4 @@ date = 2024-06-16T22:31:24+02:00
* [Developing ExectOS](/contributing/developing-exectos)
* [ExectOS Coding Style](/contributing/coding-style)
* [First steps with GIT](/contributing/working-with-git)
* [Setting Up XTchain](/contributing/setting-up-xtchain)
* [Submitting Patches](/contributing/submitting-patches)

View File

@ -2,56 +2,40 @@
title = 'Building ExectOS'
date = 2024-06-18T16:37:24+02:00
+++
ExectOS must be compiled with the XTChain toolchain. Make sure you have already [downloaded](/download) and installed
XTchain and [set up the environment](/contributing/setting-up-xtchain) before proceeding. Once this is done and the
source code is ready, open a terminal and launch the XTChain Build Environment.
ExectOS must be compiled with the XTChain toolchain. Make sure you have already [downloaded](/download) and installed it.
Once this is done and the source code is ready, open a terminal and launch the XTChain Build Environment.
```
xtchain
```
Next, set your target architecture and build type. You can choose between:
* Architecture: i686 (32-bit) or amd64 (64-bit)
* Build type: DEBUG (for development and debugging) or RELEASE (for production)
Use the following commands:
Then, set your target build architecture and the build type and configure the project. Choose `i686` or `amd64` depending
on the architecture you wish to target. The build type can be either `DEBUG` for debugging purposes or `RELEASE` for
a production build.
```
charch [i686|amd64]
chbuild [DEBUG|RELEASE]
```
Now, configure the project:
* On Linux, run:
```
./configure.sh
```
* On Windows, run:
```
.\configure.ps1
```
Once configuration is complete, navigate to the build directory and compile the source:
After the sources are configured, navigate to the build directory and compile the source code.
```
cd build
xbuild
```
After the build completes, the compiled binaries will be located in the `build/output/binaries` directory. Additionally,
depending on the selected build type, you may also find debug symbols in PDB format inside the `build/output/symbols`
folder. Precompiled libraries intended for linking other software with XTDK are available in the `build/output/library`
directory.
Afterwards, you will find the binaries in `build/output/binaries` directory. Apart from that, depending on build type, you
can also find a debug symbols in PDB format in `build/output/symbols` folder and precompiled libraries that can be used to
link other software using XTDK in `build/output/library`
## Creating Qemu Disk Image
If you want to build a bootable disk image for use with QEMU, you can do so with the following command:
If you want to build a disk image that is ready to use with Qemu, you can use the following command:
```
xbuild diskimg
```
This command generates a virtual disk image that can be directly booted in a QEMU virtual machine. You can also convert
this image into other formats compatible with alternative hypervisors such as VirtualBox or VMware.
This will create a disk image that you can boot within a Qemu Virtual Machine, or convert to other format for use within
other hypervisor, like VirtualBox.
## Testing with Qemu
Once ExectOS has been successfully compiled, you can test it in a virtual environment. The recommended approach is to use
QEMU, which supports both hardware virtualization (via KVM) and software emulation (via TCG).
After successfully compiling ExectOS, you can test it using QEMU with either hardware virtualization (KVM) or software
emulation (TCG). To start QEMU with KVM, use the testkvm target, and for TCG emulation, use the testtcg target. These
targets are provided for convenience and can be executed directly from the build directory. For example, run
`xbuild testkvm` to launch QEMU with hardware virtualization, or `xbuild testtcg` to use software emulation:
After successfully compiling ExectOS, you can test it using Qemu with either hardware virtualization (KVM) or software
emulation (TCG). To start Qemu with KVM, use the `testkvm` target, and for TCG emulation, use the `testtcg` target. These
targets are provided for convenience and you can run these commands from your build directory.
```
xbuild testkvm # For KVM hardware virtualization
```
@ -59,20 +43,16 @@ or
```
xbuild testtcg # For TCG software emulation
```
These commands will automatically configure QEMU with the appropriate settings and start the virtual machine. Keep in mind
that QEMU is not distributed with XTchain and must be installed manually.
In addition to QEMU, you can also test ExectOS using Bochs, an IA-32 (x86) PC emulator that offers a different emulation
environment. To launch Bochs with the ExectOS disk image, run the following command:
These commands will automatically configure Qemu with the appropriate settings for ExectOS and start the virtual machine.
In addition to Qemu, you can also use Bochs for emulation. Bochs is an IA-32 (x86) PC emulator that provides a different
emulation environment. To launch Bochs with the ExectOS image, run the following command:
```
xbuild bochsvm
```
This will start the Bochs emulator with ExectOS loaded, allowing you to test the system in a context that may offer
different debugging capabilities compared to QEMU. Like QEMU, Bochs is not bundled with XTchain and needs to be installed
separately.
This will start the Bochs emulator with ExectOS loaded, allowing you to test the system in an environment that may offer
different debugging capabilities compared to Qemu.
The performance and debugging experience will differ depending on which emulator you use. KVM requires a host system with
hardware virtualization support and offers the best performance. TCG is a pure software-based emulator and works even on
systems without virtualization capabilities, albeit at slower speeds. Bochs, while slower than both, provides a rich set of
debugging features which can be especially helpful when troubleshooting complex or low-level issues. Alternatively, you may
use other hypervisors like VMware or VirtualBox by manually configuring them to boot from the generated disk image.
Remember that the performance and debugging features will vary depending on whether you use KVM, TCG, or Bochs. KVM
requires that your host machine supports hardware virtualization, while TCG is a pure software emulator which works on
systems without hardware virtualization. Bochs provides a rich set of debugging features, which can be useful when
troubleshooting complex issues.

View File

@ -1,80 +0,0 @@
+++
title = 'Setting up XTchain'
date = 2025-07-16T19:29:14+02:00
+++
XTchain is a script-based compilation environment designed to streamline complex build processes across multiple platforms.
This guide explains how to set up and use XTchain efficiently on your system. You will learn how to launch the XTchain
environment, configure your terminal for convenience, and ensure that your development setup is ready for building projects
like ExectOS.
## Setting Up XTchain on Linux
Setting up XTchain on Linux is designed to be as straightforward and hassle-free as possible. Once you have downloaded and
extracted the XTchain archive, there is virtually no additional configuration required to get started. Simply navigate to the
extracted directory and launch the main executable script:
```
/path/to/xtchain/xtchain
```
This single command initializes the entire XTchain environment, automatically setting up all necessary paths, environment variables,
and dependencies behind the scenes. The script ensures that your terminal session is fully prepared for building ExectOS right away,
so you can focus on development rather than setup.
Because Linux inherently supports scripting and shell environments, XTchain takes advantage of native shell features to provide
a seamless experience. The environment is preconfigured to recognize common build tools and utilities, minimizing any need for
manual intervention.
For convenience, you might consider either creating an alias in your shell configuration file (such as .bashrc or .zshrc):
```
alias xtchain="/path/to/xtchain/xtchain"
```
or adding the XTchain directory to your PATH environment variable:
```
export PATH="/path/to/xtchain:$PATH"
```
After making either change, reload your shell configuration with source ~/.bashrc (or source ~/.zshrc) to make the modification
effective immediately. This way, you can start XTchain from anywhere simply by typing xtchain, without navigating to its folder
each time.
## Setting Up XTchain on Windows
On Windows, the simplest way to launch XTchain is by defining a dedicated profile in Windows Terminal that automatically
opens PowerShell, loads the XTchain environment, and remains interactive for further commands.
### 1. Create a Custom Windows Terminal Profile
A dedicated terminal profile ensures that every time you open XTchain, the environment is preconfigured and ready to use.
1. Open **Windows Terminal**.
2. Click the down-arrow next to a tab and select **Settings**.
3. Choose **Add a new profile**.
4. In the **Command line** field, enter:
```
%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe -ExecutionPolicy Bypass -NoExit -File "C:\Path\To\XTchain\xtchain.ps1"
```
Replace C:\Path\To\XTchain with the actual folder where xtchain.ps1 resides. Give the profile a name (for example, XTchain),
assign an icon if desired, and save the settings. Now when you select the XTchain profile, Windows Terminal will launch
PowerShell, bypass execution restrictions, run the initialization script, and keep the window open. The command works as follows:
it starts the built-in PowerShell executable (%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe), temporarily disables
the script execution policy with **-ExecutionPolicy Bypass**, prevents the terminal from closing after the script finishes using
**-NoExit**, and runs the XTchain initialization script specified with **-File "C:\Path\To\XTchain\xtchain.ps1"**. This setup
ensures that the XTchain environment is ready every time you open the terminal.
### 2. Handling Execution Policy Errors
When running the profile, you might see the following error message: **File ... cannot be loaded because running scripts is
disabled on this system**. This indicates that your system's execution policy is set to block all or unsigned scripts. To
permanently fix it, open PowerShell as Administrator and enter:
```
Set-ExecutionPolicy RemoteSigned
```
This policy allows:
- All locally created scripts (including xtchain.ps1) to run without signing.
- Scripts downloaded from the internet to require a trusted digital signature.
Warning: Only change execution policy if you trust the scripts you run.
### 3. Use Git Bash for a Unix-like Environment
As an alternative, if you have installed Git for Windows along with the bundled MSYS2 tools, you can leverage its Bash shell and
Unix-style scripts to initialize XTchain exactly as on Linux. During the installation process, you have the option to include a set
of additional Unix utilities that, combined with the Bash shell, provide a powerful and familiar development environment. This setup
allows you to run XTchain's shell scripts seamlessly on Windows, mirroring the Linux workflow and ensuring consistency across
platforms without the need for platform-specific adjustments.
For added convenience, you can also configure a dedicated profile in Windows Terminal that automatically launches Git Bash with the
XTchain environment pre-initialized. This makes it easy to jump straight into a ready-to-use shell session. The process for creating
this terminal profile is analogous to the one described in section 1.

View File

@ -3,7 +3,6 @@ title = 'Documentation'
date = 2024-06-16T22:27:36+02:00
+++
### Getting Started
* [AI-Assisted Contributions](/ai-assisted)
* [Frequently Asked Questions](/faq)
* [Get in Touch](/contact-us)
* [Installation Guide](/documentation/install-guide)

View File

@ -1,28 +0,0 @@
+++
title = 'Streamlining for the Future: Inside the Latest XTchain Overhaul'
author = 'Aiken Harris'
date = '2025-07-10T15:48:42+02:00'
+++
In the dynamic world of software development, the ExectOS project has emerged as a captivating endeavor by a community
of passionate programmers. This novel operating system, designed for enthusiasts and innovators alike, has recently
undergone significant enhancements, particularly within its core toolchain, XTchain.
The XTchain toolchain, an integral component of the ExectOS build process, has been meticulously streamlined. The previous
versions included an assortment of elements that, upon reflection, were deemed superfluous. Most notably, the entire
mingw32 suite has been removed. The rationale behind this decision is founded on the existence of multiple established
toolchains capable of building Windows applications using both GCC and LLVM. Given that ExectOS, despite employing PE
executable files, is distinct from Windows, it was determined unnecessary for the dedicated toolchain to incorporate
Windows-specific headers and libraries.
As the ExectOS project evolves, it may eventually integrate its own libraries and headers. However, at the present stage,
the essential tools for system construction suffice. The leaner XTchain now comprises the LLVM compiler, additional Wine
tools for resource file handling (such as wmc and wrc), CMake, and Ninja. Additionally, the toolchain's prior branding
elements have been eliminated to pave the way for the use of system-native tools in building ExectOS—albeit not the
recommended method—thereby facilitating contributions from unsupported systems like OS X.
A significant milestone for XTchain is the introduction of support for the Windows operating system. This advancement
allows anyone to download a dedicated package containing the complete set of necessary tools to compile ExectOS under
Windows, marking a pivotal step toward broadening developer accessibility.
These changes reflect ExectOS's ongoing commitment to accessibility, performance, and community involvement. We invite
developers and enthusiasts to explore the updated toolchain and join us in shaping the future of this operating system.

View File

@ -1,33 +0,0 @@
+++
title = 'XTchain 3.0.0 Released: Now Available for Windows'
author = 'Aiken Harris'
date = '2025-07-11T09:04:17+02:00'
+++
We are proud to announce the release of XTchain 3.0.0, marking a major milestone in the evolution of the XTOS
build toolchain. This new version introduces a streamlined experience, improved platform support, and updated core
components - further solidifying XTchain's role as a reliable foundation for building the ExectOS operating system.
The new release is available now. Download XTchain 3.0.0 from the [release page](https://github.com/xt-sys/xtchain/releases/tag/3.0.0).
We invite developers and power users to explore the updated XTchain, try out the new Windows support or Lite editions, and
contribute to the growing ExectOS ecosystem.
#### What's New in XTchain 3.0.0
This release brings several key improvements and changes:
* **Removal of mingw32:** XTchain no longer includes the mingw32 suite, significantly reducing complexity and size. Given
that ExectOS uses PE executables but is not Windows, the inclusion of Windows-specific headers and libraries was deemed
unnecessary.
* **Toolchain simplification:** Redundant elements and legacy branding have been removed, making it easier for developers
to integrate system-native tools if desired (not recommended for production use).
* **Updated core tools:**
* LLVM upgraded to 21.0.7
* Wine tools upgraded to 10.11
* CMake upgraded to 4.0.3
* Ninja upgraded to 1.13.0
* **Windows support:** For the first time, XTchain is officially available as a complete binary package for Windows,
allowing users to build ExectOS natively on the platform.
#### Introducing the Lite Editions
XTchain 3.0.0 also debuts **Lite versions** of the toolchain. These minimalist editions include only the essential build
environment. The Lite editions are intended for advanced users who already have - or prefer to install - LLVM, CMake, and
Ninja from official sources. These variants offer flexibility without compromising the core functionality required to build
ExectOS.

View File

@ -1,34 +0,0 @@
+++
title = 'XTchain 3.0.1 Released: Bug Fixes & Updates'
author = 'Aiken Harris'
date = '2025-07-18T10:54:37+02:00'
+++
Just days after the milestone release of XTchain 3.0.0, we have launched version 3.0.1, delivering targeted improvements
and essential bug fixes to correct initial regressions and improve overall functionality across platforms.
XTchain 3.0.1 may appear as a minor version bump, but its release demonstrates the project's commitment to rapid iteration
and user-focused refinement. The update includes the latest versions of LLVM, Ninja and Wine tools (such as widl, wmc and
wrc) - three essential tools in the modern compilation ecosystem. These updates were integrated specifically in response
to the recent upstream releases, ensuring XTchain remains compatible with the most up-to-date and performant build
infrastructure.
While 3.0.0 marked a significant leap forward for the project - introducing a reworked toolchain architecture and broader
platform support - version 3.0.1 builds on that foundation by focusing on polish, reliability, and cross-platform parity.
#### Key Highlights in XTchain 3.0.1
* **Bug Fixes Across the Board**: We addressed several issues uncovered after the 3.0.0 release, including a lingering
problem where XTchain attempted to display the version of the non-existent windres tool - an issue that stemmed from an
incomplete cleanup of deprecated tool references.
* **Improved Windows Environment Support**: One of the top user-requested features has landed: XTchain now works seamlessly
within GIT Bash on Windows. This enhancement makes it easier for developers on Windows to interact with the toolchain
using familiar Unix-like workflows. Additionally, a new script has been included to help initialize the build environment
automatically.
* **Enhanced XBUILD Behavior**: A particularly frustrating issue with the xbuild command - where it silently ignored
user supplied parameters has been resolved. The tool now correctly passes all build arguments, ensuring predictable
behavior for more complex project setups.
* **Unified Cross-Platform Experience**: A key development goal in 3.0.1 was to harmonize behavior across Linux and Windows
environments. From consistent output formatting to standardized toolchain handling, users can now expect a much more
uniform experience regardless of their platform of choice.
Users are encouraged to update as soon as possible to benefit from the improved tooling, better compatibility, and refined
user experience.

View File

@ -1,2 +1,2 @@
{{ $paginator := .Paginate (where site.RegularPages.ByDate.Reverse "Type" "news") 5 }}
{{ $paginator := .Paginate (where .Site.RegularPages "Type" "in" (slice "news")) }}
{{ partial "list.html" (dict "context" . "paginator" $paginator) }}

View File

@ -1,7 +1,7 @@
<div class="wrapper_footer">
<div class="footer">
<div class="footer-left">
Copyright&copy; 2017 - 2025, CodingWorkshop
Copyright&copy; 2017 - 2024, CodingWorkshop
</div>
<div class="footer-right">
Content is available under <a href="https://www.gnu.org/licenses/fdl-1.3.html">GNU Free Documentation License 1.3 or later</a>.