CiC, also known as Cross-Interpreter Communication, is defined as an innovative development standard that transcends the traditional concept of integration. Instead of simply connecting systems, CiC focuses on interpretation: every CMS (such as WordPress, Joomla, or Drupal), every API, and every programming language is transformed into an autonomous interpreter capable of executing, translating, and exchanging logic in real time.
These features make CiC ideal for high-complexity environments where speed and flexibility are critical.
The philosophy behind CiC is based on the idea that technological systems must operate as a harmonious whole, promoting decentralization without sacrificing interoperability. Ascoos OS, as a PHP-based kernel, does not simply "join" systems—it synthesizes them into an ecosystem where each element contributes actively. This approach avoids the complexity of central controllers, such as in blockchain, and focuses on user-centric applications.
In contrast to traditional methods, CiC promotes result synthesis, where outputs from different interpreters (e.g., an article from WordPress and data from an IoT API) are automatically combined into customized responses. This philosophy reflects the evolution of Ascoos OS toward a more semantic and automated environment.
CiC is a pillar in the implementation of Web 5.0 by Ascoos OS. Web 5.0 is defined as a user-centric internet that combines the simplicity of Web 2.0 with the decentralization of Web 3.0, without the complexities of blockchain. It is based on elements such as:
CiC enhances these elements through CMS interpretation, enabling seamless integration of decentralized resources. For example, a CMS can "interpret" data from DWNs in real time, creating a unified, secure usage environment. This connection makes Ascoos OS a pioneer in the Web 5.0 era.
As a new technology (💠) of Ascoos OS, CiC is deeply integrated into its core, collaborating with tools like the OTA (One To All) technology, which uses a single core to manage all domains and subdomains. Additionally, it connects with the evolution of ASCOOS CMS toward Oxyzen, a next-generation CMS with desktop-like appearance, drag & drop features, macro scripting, and built-in AI modules.
In the development timeline of Ascoos OS, the completion of CiC is scheduled for 2026, as part of the expansion to ~2500 classes, including AI, NLP, and IoT features. This will enable the release of the public commercial Beta under the AGL license, with CiC as a key tool for developers.
CiC brings theory to practice through simple yet powerful examples. Below, we present a case study that demonstrates the combination of WordPress and Joomla within Ascoos OS for Web 5.0 interoperability. This example uses interpreters to translate WordPress hooks into macros and retrieve data from Joomla API, creating a unified output.
In this scenario, we load the Joomla and WordPress cores via autoloaders (assuming collaboration with their development teams). We use Ascoos OS classes to interpret a WordPress hook (add_action), translate it into a macro, and combine it with user data from Joomla. The result is a synthesis that displays customized data.
<?php
/**
* @ASCOOS-NAME : Ascoos OS
* @ASCOOS-VERSION : 26.0.0
* @ASCOOS-SUPPORT : support@ascoos.com
* @ASCOOS-BUGS : https://issues.ascoos.com
*
* @desc <English> CiC example combining WordPress and Joomla in Ascoos OS for Web5 interoperability.
* @desc <Greek> Παράδειγμα CiC που συνδυάζει WordPress και Joomla στο Ascoos OS για διαλειτουργικότητα Web5.
*
* @since PHP 8.2.0
*/
declare(strict_types=1);
// Loading Ascoos OS autoloader
global $AOS_LIBS_PATH;
require_once $AOS_LIBS_PATH . '/joomla/autoload.php';
require_once $AOS_LIBS_PATH . '/wp/autoload.php';
use ASCOOS\OS\Kernel\CMS\Interpreters\{
TWordpressInterpreterHandler,
TWordpressHookTranslatorHandler,
TJoomlaApiBridgeHandler
};
use ASCOOS\OS\Kernel\Arrays\Macros\TMacroHandler;
try {
$macroEngine = new TMacroHandler();
// WordPress hook
$wpInterpreter = new TWordpressInterpreterHandler(['cms' => ['cmsType' => 'wordpress']]);
$wpHook = $wpInterpreter->interpretHooks("add_action('wp_head', 'my_custom_head', 10, 1)");
$wpTranslator = new TWordpressHookTranslatorHandler();
$wpMacro = $wpTranslator->translate($wpHook, ['hook' => 'wp_head']);
$macroEngine->addConditionalMacro(
$wpMacro->condition->condition,
fn(...$p) => $wpMacro->executeIfTrue(...$p)
);
// Joomla API call
$joomlaApiBridge = new TJoomlaApiBridgeHandler();
$userData = $joomlaApiBridge->bridge('JFactory::getUser', []);
// Combining results
$macroEngine->runAllConditional();
echo "@render_combined({$userData['name']})\n"; // Display: @render_combined(Ascoos user)
} catch (Exception $e) {
echo "Error: {$e->getMessage()}";
}
?>This example shows how CiC transforms isolated CMS into collaborative interpreters, ideal for decentralized applications.
The related technology LiL (Language-in-Language), scheduled for Q4 2028, extends CiC by converting web syntax (e.g., HTML, JS) or other languages (Delphi, Pascal, Python, C++) into executable PHP commands. Example: A button with onclick="run:macro('deploy')" is automatically translated into $macroHandler->runMacro('deploy');.
To see how LiL works in practice, let's examine a simple program in Pascal that uses commands like writeln and write for text output and file writing. LiL automatically converts it into equivalent PHP code, preserving the logic and adapting to PHP syntax.
Program Example75;
{ Program to demonstrate the Write(ln) function. }
Var
F : File of Longint;
L : Longint;
begin
Write ('This is on the first line ! '); { No CR/LF pair! }
Writeln ('And this too...');
Writeln ('But this is already on the second line...');
Assign (f,'test.tmp');
Rewrite (f);
For L:=1 to 10 do
write (F,L); { No writeln allowed here ! }
Close (f);
end.<?php
$L = 0;
echo "This is on the first line ! ";
echo "And this too...\n";
echo "But this is already on the second line...\n";
$F = fopen("test.tmp","w");
for ($L = 1; $L <= 10; $L++) {
fprintf($F, " %u", $L);
}
fclose($F);
?>This conversion allows seamless integration of legacy code (like Pascal) into Ascoos OS, enhancing CiC's interoperability and making the system accessible to developers from diverse backgrounds.
These implementations transform the UI into a programmable interface, making Ascoos OS accessible to developers of all levels.
At the core of CiC lies the semantic core, a structure that manages interpreter interactions. It supports multiple languages via LiL, with an emphasis on conversion to PHP for optimal performance. Technically, it includes:
Adopting CiC brings significant advantages:
CiC will evolve alongside Ascoos OS:
The CiC technology is not just an innovation—it is the heart of Ascoos OS, bringing the vision of Web 5.0 to life. With an emphasis on interpretation and synthesis, it opens new horizons for decentralized, smart applications. The provided case study and LiL example demonstrate its practical value, making CMS and language integration simpler and more powerful than ever.
For more examples and code, explore the examples folder.