Our goal? Well, in a playful tone, we could say that we're determined to make front-end developers obsolete and send them packing!
Just like coachmen became obsolete with the invention of the automobile, front-end developers might soon find themselves searching for new career paths. Thanks to our Deterministic AI for Automatic Front-End Generation, manually writing user interfaces will be a thing of the past.
Gone are the days of endless XAML bindings and complex integrations, the total automation has arrived, and the revolution is here. Of course, talented front-end developers will find new ways to apply their skills, but one thing is clear: the way we build front-ends is about to change forever!
Discover the future of software development with our groundbreaking platform, engineered to completely automate Blazor front-end creation. This innovative technology allows development teams to focus on the core backend libraries and critical application functionalities, while the front-end is built seamlessly and effortlessly.
The idea behind this development system is that the programmer must focus only on the program's functionality, in practice the development focuses on the creation of a library without a graphical interface and protocols that allow the front-end to interact with the back-end. Once the back-end is compiled and the assembly is produced, an AI analyzer examines it and automatically creates the front-end with all the iteration mechanisms with it. This speeds up development considerably. The front-end is created complete with everything, including field validation mechanisms. API and iteration systems between GUI and back-end. In the various tutorials published, for convenience the front-end project coincides with the back-end, this to facilitate these examples, from the practical side it is possible to create a back-end project as a library (therefore without a GUI), and create separate projects for the generation of Web, Mobile and Desktop applications: We are working on 3 GUI generators that cover all the cases, in this way by writing a single back-end you will have the Web, Mobile and Desktop apps ready in one go.
In the rapidly evolving landscape of digital transformation, the demand for scalable, secure, and efficient cloud-based applications has never been greater. Governments across Europe, including Italy, are investing heavily in digital infrastructure through initiatives like the National Recovery and Resilience Plan (PNRR), which allocates billions of euros to support cloud migration, interoperability, and the modernization of public services. At the heart of this transformation lies a unique opportunity: UISupportBlazor, a groundbreaking technology that automates the creation of web applications by analyzing backend assemblies and generating complete front-end interfaces in real time. This deterministic AI-driven platform eliminates the need for manual front-end development, dramatically accelerating time-to-market and reducing development costs by up to 70%. Unlike conventional frameworks, UISupportBlazor is not just a productivity tool—it is a strategic enabler. By allowing developers to focus solely on backend logic, it ensures that applications are inherently cloud-ready, interoperable, and aligned with the technical standards required by PNRR funding programs. In essence, this technology transforms the development process into a streamlined pipeline for producing financially eligible projects, ready to be deployed across public administrations and private sectors alike. The potential for return on investment is substantial. Consider the precedent set by Xamarin, a cross-platform development tool acquired by Microsoft in 2016 for an estimated $400–500 million. Xamarin’s value lay in its ability to unify mobile development across platforms—UISupportBlazor goes further by automating the entire front-end layer and supporting web, mobile, and desktop applications from a single backend source. This positions the technology not only as a development accelerator but as a foundation for scalable software factories, capable of producing compliant applications at industrial speed. Moreover, the platform’s deterministic architecture ensures precision, security, and reliability—qualities that are indispensable in sectors such as healthcare, education, and government services. Its automatic API generation system further simplifies cloud deployment, removing the need for complex REST integrations and reducing the risk of human error. Investing in UISupportBlazor means investing in the future of software development. It means backing a technology that aligns perfectly with national and European digital agendas, while offering tangible economic advantages: reduced labor costs, faster delivery cycles, and access to public funding streams. It is a rare convergence of innovation, compliance, and profitability. This is not just a tool—it is a paradigm shift. And for investors seeking to be part of the next wave of digital infrastructure, UISupportBlazor offers a front-row seat. Investing in UISupportBlazor means investing in the future of software development. It means backing a technology that aligns perfectly with national and European digital agendas, while offering tangible economic advantages: reduced labor costs, faster delivery cycles, and access to public funding streams. It is a rare convergence of innovation, compliance, and profitability. This is not just a tool—it is a paradigm shift. And for investors seeking to be part of the next wave of digital infrastructure, UISupportBlazor offers a front-row seat. Although the current implementation of UISupportBlazor focuses on web applications using Blazor, the core assembly analyzer was designed from the beginning to be application-type agnostic. Since it analyzes compiled assemblies rather than source code, and .NET assemblies are generated from any supported language (C#, F#, VB.NET, etc.), the technology is inherently language-independent and platform-neutral. This allows developers to write backend logic once and automatically generate front-ends for web, desktop, and mobile platforms. The roadmap includes extending support to these platforms, transforming UISupportBlazor into a true cross-platform development engine. Unlike traditional frameworks that require manual UI development for each target, UISupportBlazor offers full automation, drastically reducing development time and effort. This positions the technology as a superior solution for organizations seeking to accelerate delivery cycles and reduce costs without compromising on quality or flexibility. By leveraging .NET assemblies as the universal interface for front-end generation, UISupportBlazor naturally integrates into the Microsoft development ecosystem. It enhances the value of existing Microsoft technologies by streamlining the development pipeline and enabling rapid prototyping and deployment across platforms. An investment in this technology not only reinforces Microsoft's leadership in developer productivity and platform unification, but also promises substantial economic returns through reduced time-to-market and scalable software production.
The relationship between programming languages, machine code, and artificial intelligence reveals a profound insight that forms the foundation of UISupportBlazor's approach. When developers write backend code in languages like C#, they are essentially crafting descriptions in a form of pseudo-English that humans can read and comprehend. These high-level instructions are not directly executed by the machine but serve as input for the compiler, which transforms them into assembly code containing the precise instructions that processors execute. This transformation process is entirely deterministic and produces output at zero additional cost as a natural byproduct of software compilation. The innovation underlying UISupportBlazor lies in recognizing that this assembly represents the most detailed, unambiguous specification of software behavior possible. While a natural language prompt to a generative AI system might describe what a user interface should do, and source code explicitly defines backend logic, the compiled assembly contains complete metadata about types, properties, methods, and architectural decisions with absolute precision. It is, in essence, the ultimate deterministic prompt, expressed not in ambiguous natural language but in verifiable structural information that eliminates all interpretive latitude. This represents a paradigm shift in how we approach automation. Traditional generative AI receives partial specifications through prompts and must infer missing details based on probabilistic training patterns. Developers using such systems attempt to make prompts increasingly detailed to constrain this inferential process, but natural language inherently carries ambiguity that cannot be fully eliminated. Programming languages resolve this ambiguity by providing formal syntax and semantics, yet even source code requires interpretation by human developers to understand design intent. The assembly, however, contains the crystallized result of all design decisions, rendered in a format that permits no ambiguity whatsoever. The practical advantage becomes clear when we consider critical systems in domains such as banking, healthcare, or industrial control. In these contexts, software vulnerabilities arising from subtle interpretive errors in code generation can have catastrophic consequences. A banking application with security gaps might enable unauthorized asset transfers. Medical software with logic flaws could endanger patient lives. Industrial control systems with unexpected behavior might cause physical damage or safety incidents. These scenarios demand not merely functional correctness but absolute certainty that implementation matches specification. Generative AI systems, operating through probabilistic mechanisms, introduce discretionary elements into code generation. Two identical prompts might produce subtly different outputs, and the training data underlying the model inevitably contains biases that influence results in ways that may not be immediately apparent. For exploratory development or rapid prototyping, this flexibility proves valuable. For mission-critical systems subject to rigorous certification requirements, this probabilistic nature fundamentally conflicts with the need for reproducible, verifiable behavior. UISupportBlazor circumvents this limitation by leveraging the assembly as its source of truth. Because the assembly is generated deterministically from verified source code, and because UISupportBlazor's transformation from assembly to user interface follows fixed algorithmic rules, the entire process maintains the same deterministic properties as compilation itself. Given identical backend code, the system produces an identical front-end interface every time, with mathematical certainty. This is not interpretation or inference but direct transformation of complete specifications into corresponding implementations. The approach also capitalizes on an economic reality: assemblies are produced as a natural, zero-cost consequence of software development. Every compilation generates comprehensive metadata that describes the application's structure, and runtime instances provide concrete state information. UISupportBlazor utilizes these existing artifacts without requiring additional specification effort from developers. The backend code serves simultaneously as functional implementation and as exhaustive specification for front-end generation, eliminating redundant description work while ensuring perfect synchronization between layers. For organizations operating under strict regulatory frameworks such as ISO standards, SOC 2 certification, or HIPAA compliance, this deterministic traceability provides substantial value. Auditors and certification bodies require demonstrable correspondence between specifications and implementations. When the front-end is mechanistically derived from verified backend assemblies, this correspondence is inherent and provable. The entire audit trail becomes transparent: source code produces assembly through compilation, assembly drives front-end generation through algorithmic transformation, and every element can be traced to its origin. The technology also addresses a critical security consideration. When generative AI produces code, that code must be treated as potentially containing subtle vulnerabilities introduced through the model's probabilistic nature. Security reviews must examine AI-generated code with the same rigor applied to code from untrusted sources. UISupportBlazor eliminates this concern because it generates nothing beyond direct reflection of explicitly coded backend logic. The attack surface remains confined to the backend implementation, which development teams have full control over and can secure through established practices. This distinction matters particularly in contexts where software behavior directly impacts physical safety or financial integrity. Medical device manufacturers building patient monitoring systems need absolute assurance that displays accurately reflect sensor data processing logic. Financial institutions processing transactions require certainty that user interfaces faithfully represent underlying business rules. Industrial control systems managing physical processes demand guaranteed correspondence between control logic and operator interfaces. UISupportBlazor's deterministic approach provides this assurance through its fundamental architecture rather than through extensive testing and validation of potentially variable outputs. The concept can be understood as elevating assembly metadata to the role it was always capable of serving but which traditional development practices never fully exploited. Programming languages were created to make software development humanly feasible, introducing abstraction layers between human thought and machine execution. Compilers bridge this gap by transforming high-level code into executable instructions. UISupportBlazor extends this transformation chain one step further, using the compiled result as the definitive specification for generating corresponding user interface components. The entire process maintains the deterministic, verifiable properties that make formal software development suitable for critical applications. In scenarios where generative AI's flexibility and creativity provide value, that approach remains entirely appropriate. For critical systems requiring absolute precision, reproducibility, and traceability, UISupportBlazor's assembly-driven determinism offers a categorically different solution. By treating the compiled assembly as the ultimate detailed specification—a deterministic prompt produced at zero additional cost—the technology delivers automated productivity while maintaining the rigorous reliability standards that mission-critical software demands. This synthesis of automation and determinism positions UISupportBlazor as an enabling technology for organizations that cannot compromise on either development efficiency or operational precision.
UISupportBlazor addresses the cybersecurity risks recently demonstrated by generative AI models such as Claude Mythos, which are capable of autonomously discovering and exploiting zero-day vulnerabilities in operating systems, libraries, and applications, as well as escaping confined environments. Our approach relies on a deterministic AI that generates on the fly, at runtime, the user interface and the communication channels with the backend. The code is not created probabilistically by an LLM but is derived through precise, immutable rules from the backend assembly. This eliminates the room for maneuver in which a generative model could introduce exploits, backdoors, or misaligned behaviours. For honesty and completeness, it should be noted that the system must be combined with server isolation techniques from the outside world – similar to an air gap or a digital cold storage – leaving the encrypted channel generated by the deterministic process as the only means of communication. In this configuration, even an attacker armed with advanced AI has no way to interact with the server except through an encrypted API whose form is unknown and non‑manipulable in advance. The combination of deterministic AI, robust encryption, and physical/logical isolation neutralises at the root the threats emerging from the Claude Mythos tests, restoring a level of security suitable for critical sectors such as finance, banking, and healthcare.
Automatic GUI (front-end) generator for Blazor. A powerful analyzer automatically creates the front-end with all panels and user interaction fields, analyzes the code in the back-end and automates all the client-side development work
Save time and pain by automating front-end development.
Harnessing the power of state-of-the-art AI algorithms, our platform analyzes back-end assemblies and dynamically generates the complete front-end architecture on the fly. Not only that, but it also establishes all communication pipelines between the back end and front end, ensuring a cohesive and efficient development process.
With this revolutionary approach, software development speed is boosted by an impressive 70%, unlocking unparalleled efficiency and productivity.
- Unify Your Team: Eliminate the traditional divide between back-end and front-end teams. Streamlined automation halves the need for developers while fostering a more focused and collaborative environment.
- Save Time and Resources: Reduce time-consuming communication between teams, freeing up resources to tackle complex back-end functionalities.
- Accelerate Time-to-Market: Deliver robust, fully functional applications faster than ever, giving your organization a competitive edge.
- Empower Your Developers: Let your developers concentrate on what truly matters—innovation and problem-solving—while the repetitive tasks of front-end creation are handled automatically.
- Innovative AI-Powered Design: The platform is driven by unique algorithms designed to adapt and optimize your front-end based on back-end assemblies in real-time.
- Cost Efficiency: Fewer developers, faster timelines, and automated processes mean significant cost savings for your organization.
- Enhanced Collaboration: By bridging the gap between back-end and front-end efforts, teams can work smarter, not harder.
Imagine a world where your team is no longer weighed down by front-end development bottlenecks. Our platform transforms the workflow, paving the way for quicker, smarter, and more reliable software delivery. It's not just about automation; it's about unleashing your team's potential.
"Invest in innovation. Simplify development. Lead the industry."
Join the countless organizations already revolutionizing their workflows and achieving unmatched results. Take the leap into the future of software development today!
Our technology implements an automatic API generation system for remote command access that is precise, effective, and does not require writing code. This allows you to run your applications in the cloud quickly and easily without creating complicated full REST API protocol mechanisms for integration between server and client applications. With its unique deterministic architecture, real-time API layer generation, and error-free automation, this technology sets a new standard for API development. As an officially licensed and copyrighted innovation, it ensures both security and efficiency, making it an indispensable tool for modern software development.
In the ever-evolving landscape of software development, automation plays a crucial role in enhancing efficiency and reducing manual workload. Traditional API development often requires extensive coding efforts, complex configurations, and precise prompt-based interactions with AI models, introducing room for potential misinterpretations and inconsistencies.
Our groundbreaking API generation system removes these uncertainties by adopting a fully deterministic approach that eliminates AI-driven interpretative errors and ensures absolute precision in API management.
Unlike AI-driven systems that rely on natural language prompts and model-based interpretations, our solution derives its intelligence from a provider-generated assembly. This assembly is meticulously analyzed, ensuring that API management is dynamically generated both on the server and client sides.
- No AI Interpretation Errors - Eliminates the risk of ambiguous prompt understanding or misconfiguration.
- Fully Deterministic API Generation - Every aspect of API behavior is extracted directly from a structured application assembly, ensuring precision.
- Seamless Integration - The automated process instantly generates an interactive API layer with zero manual intervention.
- Accelerated Development - Developers can focus on building features instead of troubleshooting unpredictable API responses.
- Copyright Protection - This highly innovative system is officially covered under a licensed copyright, securing intellectual property rights.
The provider-generated assembly acts as a blueprint, defining all necessary API interactions. Instead of relying on AI to interpret vague instructions, the system:
- Analyzes the assembly structure to extract essential API functions.
- Generates API endpoints dynamically, ensuring compatibility with both server-side and client-side applications.
- Integrates directly into the application workflow, delivering a plug-and-play API layer for seamless execution.
Artificial intelligence based on probabilistic models operates through interpretive mechanisms that introduce variability in outcomes. This approach proves effective in limited contexts and for simple problems where ambiguity is minimal. However, when applied to complex domains requiring absolute consistency and reproducible results, the non-deterministic nature of these systems reveals structural limitations.
Deterministic AI addresses this challenge through an alternative paradigm. Unlike systems based on natural language interpretation, this technology produces predictable and consistent outcomes thanks to its architecture devoid of discretionary components. The system processes inputs with the same reliability as a compiler translating source code into executable instructions.
The operational model rests on a fundamental principle: while in conventional programming the developer explicitly defines every aspect of software behavior, and in generative AI systems users provide partial specifications that the model must supplement through inferences, deterministic AI receives fully specified inputs. In our specific case, the system analyzes .NET assemblies containing all necessary information to generate corresponding user interfaces, without requiring any interpretive integration.
To understand the practical functioning, consider the example of automatic data entry form generation. The assembly analysis identifies classes, properties, data types, and available methods, producing a complete user interface with all required fields, validation mechanisms, and backend interaction modalities. This process follows fixed, predefined rules, ensuring the same assembly always generates the same interface.
The comparison with traditional AI, particularly Large Language Models, highlights substantial differences: where LLMs operate through probabilistic processes that can produce varying outcomes from identical inputs, deterministic AI ensures consistency and reliability through algorithms that uniquely map structured inputs to corresponding outputs.
The distinctive value of this approach lies in its ability to automate complex processes while maintaining reliability levels equivalent to manual development. This makes it particularly suitable for enterprise applications, critical systems, and contexts where quality and result consistency are fundamental requirements.
Deterministic AI doesn't represent a replacement for existing paradigms, but rather an evolutionary specialization that completes the intelligent automation ecosystem, offering a structured solution for application domains where operational precision is non-negotiable. Its capacity to transform complete specifications into consistent implementations positions this technology as an enabler for a new generation of development tools.
Most projects leveraging AI for API generation introduce uncertainty, relying on language model interpretation, which can lead to varying outputs based on prompt phrasing. Our solution bypasses this limitation entirely, ensuring a fixed, predefined approach to API creation.
By eliminating unnecessary complexity, this technology accelerates software development, reduces errors, and provides a rock-solid foundation for API-based applications.
We invite you to view and test this collection of examples, they are excellent demonstration tutorials on how to create and use this powerful tool: Demonstration applications (examples) and manuals
Among the demo tutorials you will find a project called ProjectTemplate, launch it and use it to create a blank template to bring your project to life! Increase your productivity dramatically! Repository that also contains the template generator
The implementation of this algorithm will lead to thousands of front-end developers being replaced, with profound and potentially devastating effects on their mental well-being. This breakthrough technology renders front-end developers as obsolete as coachmen were with the advent of the automobile.
The easiest way to get started is to create a basic project using the ProjectTemplate found here: Blazor Auto GUI Generator Samples: Blazor Auto GUI Generator Samples
Alternatively, you can also set up your own Blazor server project by following the steps below:
-
Create a Blazor server project, with global interactive position (be careful to set these parameters when you create your project with Visual Studio)
-
Enter the project reference or equivalent NuGet package (UISupportBlazor) to your Blazor project
-
Enable the project to be interpreted by the assembly analyzer to automatically generate the document file by adding the following tag: True:
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
- Enable HttpContext in your project (this will allow you to manage multiple sessions and therefore manage multiple users simultaneously).
Add this to your program.cs file:
// Used to get httpContext in razor pages
builder.Services.AddHttpContextAccessor();- Add the content rendering component to the navigation menu.
@inject IHttpContextAccessor HttpContextAccessor
...
...
...
...
@{
var panels = UISupportBlazor.Support.GetAllClassInfo(HttpContextAccessor.HttpContext);
}
@* Component to add for dynamic rendering of AI-generated content *@
<UISupportBlazor.Menu ClassesInfo="@panels"></UISupportBlazor.Menu>
...In the file:
Components > Layout > NavMenu.razor
You should get something like this:
@inject IHttpContextAccessor HttpContextAccessor
<div class="top-row ps-3 navbar navbar-dark">
<div class="container-fluid">
<a class="navbar-brand" href="">YourProjectName</a>
</div>
</div>
<input type="checkbox" title="Navigation menu" class="navbar-toggler" />
<div class="nav-scrollable" onclick="document.querySelector('.navbar-toggler').click()">
<nav class="nav flex-column">
<div class="nav-item px-3">
<NavLink class="nav-link" href="" Match="NavLinkMatch.All">
<span class="bi bi-house-door-fill-nav-menu" aria-hidden="true"></span> Home
</NavLink>
</div>
</nav>
@{
var panels = UISupportBlazor.Support.GetAllClassInfo(HttpContextAccessor.HttpContext);
}
@* Component to add for dynamic rendering of AI-generated content *@
<UISupportBlazor.Menu ClassesInfo="@panels"></UISupportBlazor.Menu>
</div>
- Add the generic page in the Pages folder that shows dynamically generated UI content, this page should have the name "Nav.razor" and the content must be as follows:
@page "/nav/{Id}"
<UISupportBlazor.Nav Id="@Id"></UISupportBlazor.Nav>
@code {
[Parameter]
public string? Id { get; set; }
}
- Adapt the contents of the \Components\Layout\NavMenu.razor.css file, as shown here:
.navbar-toggler {
appearance: none;
cursor: pointer;
width: 3.5rem;
height: 2.5rem;
color: white;
position: absolute;
top: 0.5rem;
right: 1rem;
border: 1px solid rgba(255, 255, 255, 0.1);
background: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3e%3cpath stroke='rgba%28255, 255, 255, 0.55%29' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e") no-repeat center/1.75rem rgba(255, 255, 255, 0.1);
}
.navbar-toggler:checked {
background-color: rgba(255, 255, 255, 0.5);
}
.top-row {
min-height: 3.5rem;
background-color: rgba(0,0,0,0.4);
}
.navbar-brand {
font-size: 1.1rem;
}
.bi {
display: inline-block;
position: relative;
width: 1.25rem;
height: 1.25rem;
margin-right: 0.75rem;
top: -1px;
background-size: cover;
}
.bi-house-door-fill-nav-menu {
background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-house-door-fill' viewBox='0 0 16 16'%3E%3Cpath d='M6.5 14.5v-3.505c0-.245.25-.495.5-.495h2c.25 0 .5.25.5.5v3.5a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5v-7a.5.5 0 0 0-.146-.354L13 5.793V2.5a.5.5 0 0 0-.5-.5h-1a.5.5 0 0 0-.5.5v1.293L8.354 1.146a.5.5 0 0 0-.708 0l-6 6A.5.5 0 0 0 1.5 7.5v7a.5.5 0 0 0 .5.5h4a.5.5 0 0 0 .5-.5Z'/%3E%3C/svg%3E");
}
.bi-plus-square-fill-nav-menu {
background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-plus-square-fill' viewBox='0 0 16 16'%3E%3Cpath d='M2 0a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V2a2 2 0 0 0-2-2H2zm6.5 4.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3a.5.5 0 0 1 1 0z'/%3E%3C/svg%3E");
}
.bi-list-nested-nav-menu {
background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='white' class='bi bi-list-nested' viewBox='0 0 16 16'%3E%3Cpath fill-rule='evenodd' d='M4.5 11.5A.5.5 0 0 1 5 11h10a.5.5 0 0 1 0 1H5a.5.5 0 0 1-.5-.5zm-2-4A.5.5 0 0 1 3 7h10a.5.5 0 0 1 0 1H3a.5.5 0 0 1-.5-.5zm-2-4A.5.5 0 0 1 1 3h10a.5.5 0 0 1 0 1H1a.5.5 0 0 1-.5-.5z'/%3E%3C/svg%3E");
}
::deep .nav-item {
font-size: 0.9rem;
padding-bottom: 0.5rem;
}
::deep .nav-item .nav-link {
color: #d7d7d7;
background: none;
border: none;
border-radius: 4px;
height: 3rem;
display: flex;
align-items: center;
line-height: 3rem;
width: 100%;
}
::deep .nav-item ::deep a.active {
background-color: rgba(255,255,255,0.37);
color: white;
}
::deep .nav-item .nav-link:hover {
background-color: rgba(255,255,255,0.1);
color: white;
}
.nav-scrollable {
display: none;
padding-top: 1rem;
padding-bottom: 1rem;
}
.navbar-toggler:checked ~ .nav-scrollable {
display: block;
}
@media (min-width: 641px) {
.navbar-toggler {
display: none;
}
.nav-scrollable {
/* Never collapse the sidebar for wide screens */
display: block;
/* Allow sidebar to scroll for tall menus */
height: calc(100vh - 3.5rem);
overflow-y: auto;
}
}This last adjustment was made necessary because of a bug in Blazor where the ::deep directive doesn't work unless it's put first (if anyone who works on Blazor development is reading this, we suggest fixing this bug.)
- Create, in your project, the Panel directory in which to put the classes that represent the back-end of your project, these will act as the basis for the automatic creation of the front-end.
This project is led by Andrea Bruno, recognized as one of the pioneers in the field of artificial intelligence.
In the aftermath of the legendary Kasparov–Deep Blue match, which captivated the world with the promise of machines defeating humans in domains requiring intellect, Andrea saw beyond the hype. He understood that such victories were not evidence of true intelligence, but rather brute-force algorithms exploring exhaustive combinations in pursuit of optimal outcomes.
Driven by the quest for authentic intelligence, Andrea began developing a genuine AI system that moved beyond trial-and-error strategies. His groundbreaking work laid the foundation for neural network prototypes—capable of learning, adapting, and evolving—well ahead of their time.
In 1999, Andrea published his revolutionary Chess AI software in Chip Magazine, one of the most respected computing publications, sparking widespread discussion around machine learning and the future of automation. In 2002, he advanced this work further through Russia’s Komunalka Project, introducing chatbots capable of holding human-like conversations and passing rudimentary Turing tests.
These innovations marked the early steps toward today’s intelligent systems, and Andrea Bruno remains a visionary force shaping the way we think about machine learning, human-computer interaction, and AI ethics.