PyCForge v1.3.3

PyCForge is a Python-to-C source transpiler and PySide6 desktop IDE. Edit Python, convert supported programs into readable C11, inspect the generated code, and compile with an optional PCFC11 toolchain—all from one workspace. A command-line interface and Python API bring the same conversion capabilities to scripts and other development tools.

Choose Typed conversion for annotated functions and direct C interfaces, or Runtime conversion for richer Python data and behavior: Unicode text, mutable lists and dictionaries, classes, closures, comprehensions, and file-processing programs spread across multiple source files.

A workspace for Python and C

• Edit comfortably: tabbed Python documents, split views, function folding, an outline, multiple cursors, and a command palette.
• See the translation: side-by-side Python and read-only C, source diagnostics, conversion details, history, and searchable output. ForgeLens connects mapped Python and C locations in Typed mode.
• Work across files: supply up to 64 Python modules, keep their source together, and generate C from the selected primary document and its supplied dependencies.
• Stay in control: cancel background conversions, see when edits make generated output stale, and choose where to save the C result.
• Make the workspace yours: saved layouts, independent Python and C text sizes, keyboard commands, and 21 searchable offline Help pages.
• Build from the IDE: select an external PCFC11 compiler and create object files or executables with build logs, diagnostics, cancellation, and a copyable report.

Install and open

Use Python 3.11–3.13. Installation includes PySide6, NumPy, Numba, Jedi, autopep8, and their required supporting packages. Ting's local review runtime is bundled with PyCForge.

On Windows:

py -m pip install pycforge
py -m pycforge.ide

On macOS or Linux:

python -m pip install pycforge
python -m pycforge.ide

The installed pycforge-workspace command also opens the desktop app. Add --upgrade to the install command to update an existing installation. For a downloaded wheel, substitute its path for pycforge and allow pip to install dependencies; omit --no-deps.

PyCForge declares its application dependencies without version pins and does not reject installed dependency version numbers. The libraries retain their own compatibility requirements. Startup loads the application resources, offline Help, and local numerical routines before opening the workspace.

Conversion coverage

Select Transpile → Typed or Transpile → Runtime, then click Transpile or press Ctrl+Enter. The checkmark identifies the active mode, and the choice is remembered between launches. Choosing a mode does not start a conversion; changing it marks existing C output stale until you transpile again.

Text, collections, and everyday operations

Runtime conversion supports practical text-processing work: trim and normalize strings, split input into fields, join output, parse integer/float text, and build formatted reports. F-strings and str.format() support documented precision, alignment, width, and value conversions; nested containers can be printed with their supported Python representations.

Mutable lists support item assignment, append, extend, insert, pop, remove, sort, reverse, copy, clear, and index. Dictionaries preserve insertion order and support lookup, deletion, get, setdefault, update, copy, pop, popitem, and live key/value/item views. Passing lists, dictionaries, and instances between converted functions preserves their shared identity.

Everyday operations include sum, min, max, abs, round, any, all, stable sorted, lazy enumerate and zip, and supported iter/next use. These combine with comprehensions, classes, functions, defaults, and keyword calls to support connected processing tasks.

Functions, objects, and annotations

Runtime mode supports first-class functions, ordinary bound methods, and lambdas that capture surrounding variables or default values. Classes declare their fields and initialize instances through __init__; methods can update fields and share objects with other converted functions.

Optional annotations include supported unions and container types. Function, assignment, and field boundaries check the annotated values. Container annotations check their current contents at those boundaries; they do not permanently restrict later mutation through another alias.

Programs across multiple files

Open the required Python documents and choose the primary module before transpiling. Runtime imports can share functions, classes, and immutable scalar/tuple constants through aliases and re-exports. Each module has its own namespace; initialization occurs once per generated C context, preserving shared defaults and class identity.

The CLI accepts additional modules explicitly:

pycforge convert main.py --runtime-values --module helper=helper.py --output program.c

Repeat --module ID=PATH for additional files. Constants-only companion modules are supported. Imports resolve only against the supplied documents; PyCForge does not discover files or translate installed Python packages automatically.

Read, process, and write UTF-8 files

Runtime mode connects scoped open calls with string operations, collections, sorting, numeric parsing, and formatting. Read whole text or character-sized portions, iterate through lines, call processing helpers in another module, and write or append the result.

Supported file operations include read, readline, readlines, write, writelines, flush, and early close. Unicode filenames and documented newline handling are supported. Handles close on normal scope exits, return, break, continue, and runtime errors. Returned text remains available for subsequent processing. Help includes a complete multi-file report with input and output examples.

Python editing tools

Jedi provides offline completion, parameter hints, definition navigation, and name analysis. Autopep8 provides requested document or selection formatting. The compact Edit menu groups Selection, Lines, Find and Replace, Code, and Folding Functions; overflow submenus keep commands accessible on short displays.

• Write and navigate: completion with Ctrl+Space, parameter hints with Ctrl+Shift+Space, Go to Definition with F12, and return with Alt+Left. Automatic suggestions are optional.
• Edit several places: smart bracket/quote pairs, selection wrapping, and multiple cursors through Ctrl+D, Ctrl+Alt+L, or Alt+click; Escape returns to one cursor.
• Find and replace precisely: regular expressions, replacement within a captured selection, and reviewed replacement across open documents with Ctrl+Shift+H.
• Rename with review: F2 previews changes to statically resolved names in the current Python document before you apply them. Review dynamic references, string-based keyword names, and callers in other files separately.
• Format with undo: Alt+Shift+F formats the document; Ctrl+K, Ctrl+F formats a selection while preserving unselected lines. Formatting preserves the Python syntax tree.
• Browse and copy definitions: right-click the Python gutter to open Classes & Functions. Double-click or press Enter to jump to a definition; the title-bar Copy icon copies its complete source, including decorators and indentation, without moving either editor view.

Completion and formatting are available independently of conversion coverage. Background analysis uses cached results, cancellation, and process deadlines; edits invalidate stale results. Cross-file replacement keeps undo history for each open document. Save edited buffers explicitly. Help explains the navigator's source-size limits and the boundaries of document-local rename.

First conversions

Save this as input.py, select Transpile → Typed, and click Transpile:

def add(left: int, right: int) -> int:
    return left + right

The equivalent command is:

pycforge convert input.py --output generated.c

For Runtime mode, save this as greeting.py:

def greeting(name: str, *, suffix: str = "!") -> str:
    return f"Hello, {name.strip()}{suffix}"

pycforge convert greeting.py --runtime-values --output greeting.c

These examples produce callable C functions. Use a C caller or provide an eligible entry function when building an executable.

Compile with PCFC11

After transpiling, choose Transpile → Compile with PCFC11… (Ctrl+Shift+Enter). Select the compiler, target, object or executable output, entry function, and optimization. The dialog shows build logs, diagnostics, elapsed time, cancellation, and Copy Report. Editing the source cancels a build that would otherwise use outdated input.

Executable entries take no arguments: Typed entries return int; Runtime entries return int or None. Runtime executable wrappers release their memory context before exiting. PCFC11 0.1.1+ and a GCC-compatible assembler/linker are installed separately; Windows uses MinGW-w64 UCRT64. Keep PCFC11's include directory beside the compiler.

For app.py containing def start() -> int: return 0:

python -m pycforge.build app.py --entry main.start --compiler /path/to/pcfc11 --output program

Add --runtime-values for Runtime conversion. PyCForge can build the generated C, but it does not run your supplied Python or generated program. The generated Runtime C includes its value routines and does not require Python, PySide6, NumPy, Numba, or Ting when executed on a compatible host.

Ting agent feedback

Six local Ting agents review syntax, semantics, ownership, C lowering, evidence, and resources. Open Ting in the status bar to inspect findings, and use the Flow Map to follow the conversion evidence behind each review.

Ting runs offline. Its feedback is advisory and leaves your source and conversion result unchanged. Each review identifies the checks available for that conversion; it does not replace compilation or comparison with your program's intended behavior.

Command line and Python API

Use pycforge --help for commands and options, or pycforge --format json convert input.py for structured output. Convert source text from Python with:

from pycforge import ConversionRequest, PythonToCConverter

source = "def add(left: int, right: int) -> int:\n    return left + right\n"
result = PythonToCConverter().convert(ConversionRequest.from_source(source))

if result.generated_c is not None:
    print(result.generated_c)
for diagnostic in result.diagnostics:
    print(diagnostic.code, diagnostic.message)

The in-app API guide also explains Runtime requests, source bundles, conversion summaries, and generated C interfaces.

Help and supported boundaries

Press F1 or choose Help → PyCForge Help… for 21 searchable offline pages covering the editor, conversion tables, examples, diagnostics, Ting, shortcuts, and C integration. Separate references describe Typed and Runtime behavior, including a multi-file read/process/write example.

PyCForge converts the documented Python forms. Integers use signed 64-bit values; generated Runtime values belong to a memory context and remain alive until it is destroyed. Exact ForgeLens mappings are available for Typed conversion. General third-party library translation, exception recovery, asynchronous code, generators, reflection, inheritance, writable module globals, and cyclic/relative/star imports are outside the supported forms. Consult Help for numeric rules, resource limits, and C caller requirements.

License

PyCForge is free software under the GNU General Public License v3.0 only. The distribution includes LICENSE and third-party notices.

Contact Robert Cecil rcttcr5@icloud.com for request or security assistance