Development tools
The required executables are not stored in the Git repository. Download the current D2CSharp Development Build from the repository's Releases section and extract the
D2CSharp.zipasset into the repository'sbindirectory.The archive contains
D2CSharp.exe,ExtractReworked.exe, the accompanying README, and the required license and third-party notice files.
- Project Overview and Goals
- Requirements
- Setup and Getting Started
- Repository Structure
- Test File Structure and Conventions
- Development and Translation Workflow
- Interpreting Test Results
- Contributions
- Licensing
- Background
D2CSharp is a project for translating Delphi source code to C#.
D2CSharp is intended for the conversion of real user code, not only for running the project's test suite. The repository provides a dedicated Source/UserCode directory where users can place their own Delphi source files for translation. The generated C# files and any manually reworked versions are kept in corresponding UserCode directories under the target trees.
A major part of the project is the development of a free runtime library (RTL) that provides the Delphi-compatible runtime functionality required by the C# code generated by D2CSharp. Improvements made while extending the tests, converter support, MockRTL, and RTL should therefore directly benefit the translation of real Delphi applications.
The repository contains in particular:
- an independently created MockRTL,
- the actual D2CSharp RTL,
- Delphi test programs,
- dedicated directories for translating user-provided Delphi code,
- the generated C# output for tests and user code,
- manually reworked working versions,
- and Visual Studio projects used to verify and format the translated sources.
D2CSharp uses the same basic translation technology as the commercial Delphi2CSharp product, but is intentionally much simpler.
D2CSharp does not provide freely configurable translation options. Paths and other settings required by the intended project workflow are predefined.
Compared with Delphi2CSharp, D2CSharp does not provide, among other things:
- configurable preprocessor conditions,
- refactoring functions,
- DFM translation,
- generation of a life-cycle manager,
- configurable generation of mock routines.
D2CSharp is therefore not a complete replacement for Delphi2CSharp.
Even in this deliberately reduced form, however, D2CSharp can already be highly useful for practical conversion tasks.
For projects that do not require complex preprocessor configuration, DFM translation, or additional refactoring functions, the converter can automate a substantial part of the work that would otherwise have to be done manually.
Even if additional work is still required afterwards, the automatic rule-based translation provides a consistent starting point and can significantly reduce the amount of manual porting work.
D2CSharp works according to predefined translation rules.
Given the same source code, the same configuration, and the same tool version, it therefore produces reproducible C# output.
This ensures that generated code follows a consistent translation strategy and can be compared and improved systematically over longer development periods.
The actual conversion is also fast and does not require repeated computation by a generative AI system.
AI tools may of course be used when contributing to the development of the project. Regardless of whether AI tools are used, all contributions must comply with the applicable licensing and copyright requirements.
In particular, proprietary original source code from the Delphi RTL or from other components that are not appropriately licensed must not be copied or incorporated into the free RTL without the necessary rights.
The current focus of the project is the Delphi Runtime Library and fundamental Delphi language constructs.
The existing tests currently use RTL units only. VCL units are not yet part of the test suite.
A large number of the existing test files cover functions and language constructs that were already available in Delphi 7. These files therefore use the prefix d7_.
D2CSharp and the associated free RTL are under active development.
Especially during the early stages of the project, new test cases are expected to require changes to the converter, additions to the MockRTL, or further implementations in the D2CSharp RTL.
The test structure is intended precisely to make such unsupported cases visible and reproducible.
As development progresses, the proportion of Delphi programs that can be translated correctly to C# without manual post-processing should continue to increase.
The UserCode directories make the current development state directly usable for practical conversion work. Users can translate their own Delphi units, inspect the unchanged converter output, and maintain any necessary manual corrections separately from that generated result.
The project is still at an early stage of development, but the current repository already provides a working basis for further development and testing.
The current test suite contains 66 Delphi test files.
Test cases that are not yet fully functional are temporarily disabled where necessary so that the complete test application can still be built and executed.
The current RTL implementation includes a comparatively complete System.cs.
SysUtils.cs is already present, but many of its routines are still stubs and therefore do not yet provide the required runtime behavior.
Several RTL units required by the existing tests have not yet been implemented. These currently include:
StrUtilsMathClassesDateUtils
Problems found in the current test set can have several different causes:
- A required RTL unit has not yet been implemented.
- A required routine in
SysUtils.csis still only a stub. - A required routine is missing from an RTL unit that already exists.
- An existing RTL routine may be incomplete or incorrectly implemented.
- The converter itself may still require changes.
The differences between TargetGenerated/Tests and TargetWorking/Tests show where the generated C# test code currently requires manual post-processing.
Files that are identical in both directories require no manual changes. Files that differ indicate cases that still need investigation or correction.
At this stage, further changes to D2CSharp.exe are expected to be necessary as additional language constructs and RTL functionality are covered by the tests.
As the converter, the MockRTL, and the D2CSharp RTL are improved, the number of manually reworked test files should gradually decrease.
A complete standalone user manual for D2CSharp is currently not part of this repository.
Its operation and basic concepts are similar in many respects to Delphi2CSharp. The Delphi2CSharp documentation can therefore be used as a reference:
- Online help: Delphi2C#
- PDF manual: Delphi2CSharp.pdf
The workflows specific to this repository, including the MockRTL, translation of tests and UserCode, post-processing, and verification, are documented in this README, in Projects/README.md, and in CONTRIBUTING.md.
Additional details about the helper batch files in the Projects directory are documented in Projects/README.md.
The supplied Visual Studio projects are SDK-style .NET projects and currently target .NET 10 (net10.0).
A current version of Visual Studio with the .NET 10 SDK installed is recommended for development and verification of the C# sources.
D2CSharp and Delphi2CSharp require syntactically and semantically valid Delphi code.
The Delphi source code to be translated should therefore compile successfully with the Delphi compiler before it is passed to D2CSharp.
Invalid or incomplete Delphi code may result in follow-up conversion errors whose messages do not necessarily indicate the actual underlying cause.
This applies in particular to the test sources in this project:
A test should first compile and run correctly on the Delphi side before its C# translation is evaluated.
Source files intended for conversion with D2CSharp should, where possible, avoid Delphi preprocessor directives. This applies to both the repository tests and code placed under Source/UserCode.
Unlike Delphi2CSharp, D2CSharp does not provide configurable settings for preprocessor conditions.
Source code that depends on conditional compilation can therefore result in conversion errors that are difficult to interpret.
This is also one of the technical reasons why the original Delphi RTL sources cannot simply be translated with D2CSharp and used as the basis for the D2CSharp RTL.
The Delphi RTL makes extensive use of conditional compilation and is not designed for this simplified conversion workflow.
Independently of this technical limitation, proprietary Delphi RTL source code is not used as the basis for the free D2CSharp RTL for legal reasons.
Instead, the project uses the independently created sources under MockRTL/Source.
The primary goal is to translate Delphi code for the current Delphi compiler.
Using the current Delphi compiler is not, however, a strict requirement for creating test cases.
Contributors who do not have access to the current compiler may also create tests with older Delphi versions.
Where possible, a Delphi version should be used in which the string type is already Unicode-based. This better matches the direction of the current D2CSharp RTL.
Some existing tests intentionally cover language and RTL features that were already available in Delphi 7.
This is indicated by the d7_ prefix and does not mean that Delphi 7 is the preferred or primary target version of the project.
The executable tools D2CSharp.exe and ExtractReworked.exe are not stored in the Git repository.
They are provided in the current D2CSharp Development Build under the repository's Releases section.
Download the D2CSharp.zip release asset and extract its contents into the repository's bin directory.
The resulting structure should include at least:
bin/
D2CSharp.exe
ExtractReworked.exe
README.txt
Licenses/
The archive contains the executables, the accompanying README, and the required license and third-party notice files.
The license files supplied with the programs must be kept together with the executables.
The licensing of these programs is separate from the licensing of the remaining repository files.
The files under Projects expect the executable programs at the predefined paths under bin.
D2CSharp currently does not provide freely configurable paths for these tools.
The D2CSharp Development Build is a pre-release and may be updated frequently.
D2CSharp is deliberately set up so that the public development version can also be used to translate your own Delphi source code.
The repository contains a dedicated UserCode area for this purpose. Your source files remain separate from the project tests and are ignored by Git by default.
The basic workflow is:
- Copy the Delphi source files you want to translate to
Source/UserCode. - Run
Projects/D2CSharp.bat. - Inspect the unchanged converter output under
TargetGenerated/UserCode. - Use
TargetWorking/UserCodeas the working C# version and make manual corrections there if required. - Differences that must survive later regeneration can be preserved under
TargetReworked/UserCodeby the normal workflow.
Each UserCode directory contains a small README.md describing its role. The actual user source and generated files are excluded from Git, which helps prevent private or proprietary application code from being committed accidentally.
D2CSharp is still under active development. Translation of real application code may therefore reveal missing MockRTL declarations, incomplete RTL implementations, or converter cases that are not yet fully supported. Such findings are valuable for further development of the project.
After cloning the repository, the basic steps for working with the supplied tests are:
- Download the current D2CSharp Development Build from the repository's Releases section.
- Extract
D2CSharp.zipinto thebindirectory. - Verify that
D2CSharp.exeandExtractReworked.exeare present there. - Run
Projects/D2CSharp.bat. - Compare the generated test files under
TargetGenerated/Testswith the versions underTargetWorking/Tests. - Apply corrections under
TargetWorking/Testsif required. - Open the solution under
D2CSharpTestsin Visual Studio. - Build and verify the RTL and test projects.
After changes to tests, the MockRTL, RTL files, or local UserCode files, the regeneration and comparison workflow can be run again.
If only C# formatting is required, Projects/FormatAll.bat can be used without rerunning the conversion. Additional details about the batch files and the conversion log are available in Projects/README.md.
The repository root contains the general documentation and license files for the project.
These include in particular:
CONTRIBUTING.md
LICENSE
LICENSE-MPL-2.0.txt
NOTICE
README.md
The licensing of individual components is described in Section 9.
The bin directory is intended for the executable tools required to work with the repository.
These include in particular:
D2CSharp.exeExtractReworked.exe- the associated README
- the associated license files
The executable files themselves are distributed in D2CSharp.zip as part of the current D2CSharp Development Build under GitHub Releases and are not stored in the Git history.
The MockRTL directory contains a simplified representation of the Delphi RTL structure required for conversion.
Within this project, the term MockRTL refers to declaration-oriented RTL skeletons and stub implementations. It does not refer to a unit-test mocking framework.
The directory mainly consists of Source and Converted.
MockRTL/Source follows the structure and unit naming of the Delphi RTL.
The files are not copies of the Delphi RTL sources.
They were created independently from the Delphi original sources on the basis of publicly available information for the purposes of this project.
The files serve two separate purposes within D2CSharp.
First, they form the input from which the C# files under MockRTL/Converted are generated.
For this purpose, the Pascal files provide the required declarations and a skeleton structure suitable for conversion.
Second, they control the translation of the actual test and application code.
D2CSharp obtains information from them about, among other things:
- constants,
- classes,
- structures and other types,
- and the signatures of referenced routines.
The MockRTL therefore describes part of the environment in which the Delphi code being translated is to be interpreted.
It is not only the starting point for the later C# RTL implementation, but also an essential source of information used during translation.
The routines themselves normally contain no actual RTL implementation.
Procedures are empty, functions return appropriate default values, or they contain only the minimal structure required for translation.
As development progresses, these files may be extended and improved, for example when additional declarations, type definitions, constants, or routines are required for new test cases or additional RTL functionality.
The MockRTL is primarily maintained and provided by t2t-soft.
Suggestions, corrections, and contributions from other developers are explicitly welcome.
The files under MockRTL/Converted are generated automatically with Delphi2CSharp from the corresponding Pascal files under MockRTL/Source.
They represent the C# counterparts of the MockRTL.
Changes to the MockRTL should generally be made in the Pascal source files under MockRTL/Source.
The files under MockRTL/Converted are generated files and are regenerated afterwards.
The D2CSharpRTL directory contains the actual C# implementation of the runtime library required by D2CSharp.
Its directory structure and many of its file names correspond to the structure used under MockRTL.
While the routines in the MockRTL serve only as declarations or simplified stubs, the corresponding routines in D2CSharpRTL contain the actual implementations.
D2CSharpRTL therefore provides the functional runtime library used by the C# code generated by D2CSharp.
In addition to the RTL files derived from the MockRTL structure, the directory contains additional C# helper classes developed specifically for D2CSharp and provided by t2t-soft.
These helper classes extend the reconstructed RTL where additional functionality is required for a practical or technically appropriate implementation in C#.
The applicable license is determined by the license notice in the respective file.
Directly implemented helper classes may be subject to a different license than RTL files derived from the Mock sources.
The Source directory contains the Delphi source files passed to D2CSharp. It separates the repository's test suite from user-provided code:
Source/
Tests/
UserCode/
Source/Tests contains the Delphi test programs used as the common starting point for verifying translation results.
The existing test files mainly cover fundamental language and RTL features that were already available in Delphi 7. Many of these files therefore use the d7_ prefix.
The current test suite is only the beginning of a much larger set of tests and will be extended as the project develops.
Source/UserCode is intended for Delphi source files supplied by the user for actual conversion.
This is an important part of the project: D2CSharp is intended to translate real Delphi code, not merely to demonstrate the included tests.
The contents of this directory are ignored by Git except for its README.md. Private or proprietary Delphi sources can therefore be placed there locally without normally appearing as uncommitted files or being added accidentally to the public repository.
TargetGenerated contains the unchanged C# output produced by D2CSharp.exe:
TargetGenerated/
Tests/
UserCode/
TargetGenerated/Tests contains the generated counterparts of Source/Tests, while TargetGenerated/UserCode contains the generated counterparts of Source/UserCode.
Files in this tree should not be corrected manually. They document the actual output of the converter and may be overwritten whenever conversion is run.
TargetWorking contains the working C# versions:
TargetWorking/
Tests/
UserCode/
After regeneration, generated files are copied from TargetGenerated to the corresponding location under TargetWorking. If a generated file still contains errors or requires adaptation, corrections are made in TargetWorking, not in TargetGenerated.
TargetWorking/Tests is intended to contain the functional C# version of the project tests.
TargetWorking/UserCode serves the same purpose for the user's own translated Delphi sources.
TargetReworked preserves files whose working versions differ from their generated counterparts:
TargetReworked/
Tests/
UserCode/
TargetReworked/Tests contains test files for which manual post-processing is still required. TargetReworked/UserCode performs the corresponding role for user-provided code.
The directory is not intended to be maintained as an independent source tree. As part of the workflow, reworked files are derived from the differences between TargetGenerated and TargetWorking and can then be restored after a new conversion run.
For the project tests, the number of files under TargetReworked/Tests also indicates cases where automatic translation can still be improved.
The actual files in all four UserCode directories are ignored by Git; only their explanatory README.md files are kept in the repository.
The Projects directory contains the helper batch files used to run the conversion and formatting workflow.
The public repository currently includes in particular:
D2CSharp.batFormatAll.batREADME.md
D2CSharp.bat runs the complete regeneration workflow described in Section 6.
FormatAll.bat formats the generated and working C# files without rerunning the Delphi-to-C# conversion. This is useful after manual changes or before comparing files with a diff tool.
Running the conversion also creates a local log file in the Projects directory, currently named D2CSharp_log.txt.
The log records conversion progress and diagnostic messages. It is a local development artifact and is excluded from Git by the repository .gitignore rule for *_log.txt.
For details about these helper files, relative paths, formatting requirements, and the conversion log, see Projects/README.md.
D2CSharpTests contains the Visual Studio and .NET projects used to verify the generated and manually reworked C# sources.
D2CSharpRTL/D2CSharpRTL.csproj is the library project for the actual D2CSharp Runtime Library.
It contains the completed C# implementations of the required Delphi RTL functionality together with the additional C# helper classes.
Tests/Tests.csproj is the test project.
It depends on D2CSharpRTL.csproj and includes only the functional C# test files from TargetWorking/Tests.
The files are not copied into the project directory, but are included as linked files.
This keeps TargetWorking/Tests as the central storage location for the working test sources while allowing the same files to be compiled and tested directly in Visual Studio. UserCode files are intentionally not included in Tests.csproj, because user applications may have arbitrary dependencies and project structures.
The Formatting directory contains two helper projects and the batch file FormatAll.cmd.
GeneratedFormatting.csproj includes the C# files from both TargetGenerated/Tests and TargetGenerated/UserCode as linked source files.
WorkingFormatting.csproj does the same for both TargetWorking/Tests and TargetWorking/UserCode.
These projects serve as workspaces for dotnet format and are not intended to be standalone libraries of the D2CSharp RTL.
FormatAll.cmd applies consistent whitespace formatting to both sets of files.
This makes the generated and working versions of both Tests and UserCode much easier to compare with diff tools such as WinMerge.
Differences caused only by indentation or formatting are reduced, making the actual manual changes easier to identify.
No dedicated test framework is intentionally used for these tests.
This allows the same test sources to be used as directly as possible in Delphi and, after translation, in C# and optionally C++.
Dependencies on a language-specific test framework would make this goal more difficult.
Instead, the test files consist of simple test functions that each return a Boolean value.
A successful test returns True; a failed test returns False.
Each test unit should additionally contain one common test function that calls all individual test functions in sequence and combines their results.
The basic pattern is:
function TestUnitName: Boolean;
begin
Result := True;
Result := Result and TestFunction1;
Result := Result and TestFunction2;
Result := Result and TestFunction3;
end;The common test function therefore returns True only if all associated individual tests succeed.
The interface section of a test unit should normally contain only the declaration of this common test function.
The individual test functions and any helper elements used only within the unit should be declared in the implementation section.
Names of classes, interfaces, functions, and other test-related identifiers should contain an abbreviation derived from the name of the corresponding test unit.
This reduces the likelihood of name collisions with identifiers from other test units.
The names of the common test functions have so far mostly been written in lowercase only.
This is not a technical requirement and is not intended to be a mandatory rule for future tests.
Only ANSI characters should be used in the test sources.
This is intended to avoid unnecessary differences in the way the source files are handled by different compilers, converters, editors, and target languages.
A test should be written so that the original Delphi code and the generated code in C# and optionally C++ produce the same result.
The aim is that the actual test logic does not require target-language-specific modification after translation.
If tolerances are required for particular calculations or data types, they should already be handled in the Delphi test.
The Delphi test file therefore defines the result considered acceptable for all target languages.
Projects/D2CSharp.bat automates the main workflow used to translate both the repository tests and local UserCode while preserving existing manual corrections.
The same basic directory model is used for both areas:
Source -> original Delphi sources
TargetGenerated -> unchanged D2CSharp output
TargetWorking -> working C# versions
TargetReworked -> preserved manual differences
Before new output is generated, existing differences between TargetWorking and TargetGenerated are preserved under the corresponding location in TargetReworked.
For the test suite this means comparing TargetWorking/Tests with TargetGenerated/Tests. The same principle applies to UserCode.
This preserves versions that contain manual changes compared with the most recently generated output.
D2CSharp.exe translates the Delphi files under Source/Tests and the local Delphi files under Source/UserCode.
The unchanged C# results are written to the corresponding directories under TargetGenerated:
Source/Tests -> TargetGenerated/Tests
Source/UserCode -> TargetGenerated/UserCode
The generated directories therefore document the actual output of the current D2CSharp version and should not be edited manually.
The generated files are copied to the corresponding directories under TargetWorking.
Previously preserved files from TargetReworked are then restored over these copies. Existing manual corrections therefore survive a new conversion run.
Manual corrections should be made in TargetWorking, not in TargetGenerated or directly in TargetReworked.
Finally, the formatting projects under D2CSharpTests/Formatting are used to apply consistent C# whitespace formatting.
Both Tests and UserCode are formatted:
TargetGenerated/TestsTargetGenerated/UserCodeTargetWorking/TestsTargetWorking/UserCode
This makes generated and working versions easier to compare with diff tools such as WinMerge and reduces differences caused only by formatting.
After running D2CSharp.bat, generated and working versions should be reviewed where manual changes exist.
Changes to D2CSharp.exe may cause code that previously required manual correction to be generated correctly automatically. Because an older reworked version can be restored over improved generated output, such improvements may need to be incorporated manually into the working version before the obsolete correction disappears from TargetReworked.
Likewise, newly introduced translation problems should be corrected in the corresponding file under TargetWorking.
The UserCode workflow is provided so that contributors and other interested users can apply D2CSharp directly to their own Delphi sources while keeping those sources separate from the repository tests.
D2CSharpTests/Tests/Tests.csproj deliberately includes only the project test files under TargetWorking/Tests. It does not include files under TargetWorking/UserCode.
Translated UserCode may belong to applications with arbitrary dependencies and project structures. After translation and any required manual corrections, these C# files should therefore be integrated into an appropriate application project separately.
As D2CSharp.exe, the MockRTL, and the D2CSharp RTL are improved, the automatically generated C# code should increasingly approach the functional versions under TargetWorking.
With an unchanged test suite, the number of files under TargetReworked/Tests should therefore decrease over time. UserCode is not used as a project metric because its contents are local to each user.
A test file can disappear from TargetReworked/Tests once D2CSharp generates it correctly without manual post-processing.
An increase in the number of reworked test files does not necessarily indicate a regression. It may also result from new test cases whose complete support still requires improvements to D2CSharp or the RTL.
A failing test does not necessarily mean that the translation produced by D2CSharp is incorrect.
Especially during the early stages of development, some functions in the D2CSharp RTL may not yet be implemented or may only be partially implemented.
In such a case, the generated C# code may be syntactically correct while the test still fails to produce the expected result.
When a test fails, it should therefore be determined whether the cause lies in:
- the automatic translation,
- a missing or incomplete RTL implementation,
- the MockRTL,
- or the test case itself.
The tests therefore serve not only to verify the converter, but also to support the gradual completion and verification of the D2CSharp RTL.
Particularly during the early stages of the project, a substantial number of changes to the converter itself should be expected.
Changes to the converter are made by t2t-soft, because its source code is not part of this repository.
Contributions to the project are welcome.
Contributions are particularly useful in the following areas:
- completing and improving the MockRTL,
- implementing missing RTL functionality,
- correcting existing D2CSharp RTL implementations,
- adding focused new test cases,
- and providing the functional C# implementations required by new tests.
New tests are welcome.
However, because very large numbers of test files can be created quickly and every additional test may require further work on the converter or RTL, new tests should be added in a focused manner.
Contributions are especially useful when a new test case is accompanied by a working C# version or by the RTL implementation required for that test.
The source code of D2CSharp.exe is not part of this repository.
Converter defects therefore cannot be submitted directly as changes to the converter itself.
In such cases, however, a small reproducible Delphi test case and a corrected C# version are particularly helpful.
Detailed contribution rules are provided in CONTRIBUTING.md.
This repository contains components under different licenses.
Apache-2.0 is the default license for the library project unless a file is explicitly identified as MPL-2.0 or is otherwise separately licensed.
The complete license texts are available in:
LICENSEfor Apache-2.0LICENSE-MPL-2.0.txtfor MPL-2.0
This explanation does not add to or modify the applicable license terms.
The following assignments currently apply in particular:
MockRTL/Source: Delphi mock sources, Apache-2.0.MockRTL/Converted: generated C# mock files, Apache-2.0.D2CSharpRTL: generated and manually completed RTL implementations under Apache-2.0, together with directly implemented C# helper classes under MPL-2.0.Source/Tests,TargetGenerated/Tests,TargetWorking/Tests, andTargetReworked/Tests: Apache-2.0 unless individually marked otherwise.D2CSharpTests,Projects, and project documentation: Apache-2.0 unless individually marked otherwise.
The UserCode directories are placeholders for local user files and their explanatory README.md files. Delphi sources copied to Source/UserCode and the C# files produced from them are not contributions to the D2CSharp repository merely because they are processed in these directories. They remain subject to whatever copyright and licensing terms apply to the user's own code.
Directly implemented helper classes such as AnsiString.cs and related partial-class files, ArrayHelper.cs, Currency.cs, Pointer.cs, and other files marked with SPDX-License-Identifier: MPL-2.0 are covered by MPL-2.0.
The license notice in the individual file is authoritative.
Files that form part of the same partial class may be subject to different licenses.
The source code of the D2CSharp, Delphi2CSharp, Aurora2Cpp, and Delphi2Cpp converters is outside this license grant.
Programs supplied under bin are governed by their own licenses.
In particular:
D2CSharp.exe:bin/Licenses/D2CSharp.LICENSE.txtExtractReworked.exe:bin/Licenses/ExtractReworked.LICENSE.txtand any additional applicable license texts- third-party components: the license and attribution notices supplied with the relevant binary package
The executables and their license files are distributed together in the D2CSharp.zip asset of the current D2CSharp Development Build.
The presence of a LICENSE file in the repository root does not relicense these separately licensed programs under Apache-2.0.
Publicly released versions of the D2CSharp command-line tool may be made available free of charge under the separate license supplied with the tool.
The current development version is distributed through the repository's GitHub Releases section as the D2CSharp Development Build.
The development asset may be updated frequently.
The converter source code is not thereby licensed under Apache-2.0 or MPL-2.0.
Making a particular version available free of charge does not create an obligation to provide future versions, updates, maintenance, or support free of charge.
Future or special development versions may, where appropriate, be made available only to active project contributors.
This does not alter rights already granted for published versions and does not affect rights in library components distributed under Apache-2.0 or MPL-2.0.
Apache-2.0 and MPL-2.0 permit private and commercial use, modification, and distribution subject to their respective conditions.
The library may also be used together with Delphi2CSharp, Delphi2Cpp, and other products.
Apache-2.0 and MPL-2.0 files retain their respective licenses.
Combining files under the two licenses does not make all files Apache-2.0, nor does it automatically make an entire application subject to MPL-2.0.
The MPL requirements apply to MPL-covered source files.
There is no requirement to contribute changes back to this project.
When distributing Apache-2.0 components, the requirements of Section 4 of the Apache License must be observed.
These include, in particular:
- preserving required notices,
- marking modified files,
- and, where applicable, reproducing relevant
NOTICEinformation.
Attribution on a splash screen is not required.
For MPL-2.0 components, covered source files, including modifications, must remain available under MPL-2.0 when distributed as required by the license.
When executable forms containing MPL-covered code are distributed, the corresponding MPL-covered source code must be made available in accordance with the MPL, and recipients must be informed how to obtain it.
This obligation concerns the MPL-covered source and does not automatically apply to independent proprietary files or applications.
Private use alone does not create a requirement to publish modifications.
When the D2CSharp RTL is distributed separately from this repository, the applicable license texts, attribution notices, and, where required, information about availability of MPL-covered source must be included.
The original technical interest behind the tools used in this project was the development of parser generators.
Work on Delphi converters later grew out of specific customer projects.
These projects have so far mainly involved translating relatively simple Delphi code or transferring the basic structure of existing software to C# or C++.
D2CSharp now pursues a broader goal:
In addition to translating the Delphi source code itself, the runtime functionality required by that code is to be provided step by step in a freely available RTL.
The range of Delphi code that can be translated without manual post-processing should therefore continue to expand over time.