Flogram
Flogram is the first programming language designed to be written by AI. We have built Flogram from the ground up to change the way AI and code work together. Together, Flogram and AI revolutionize the developer's coding experience.
Flogram was designed to be a full-stack language. Instead of separate languages for front-end, back-end, styling, database, configuration, and graphics this can all be handled from a single simple language.
This allows us to extract all code that is relevant to specific bugs or features. Making it easier to find and fix bugs or add features.
Having all code work like it’s a back-end language gives the AI or programmer full control over what the machine executes.
# Example demonstrating Flogram's full stack capabilities with server and file interaction
server AI_ProcessingServer:
fn process_data(file_link: Link { File, heap }) -> (processed_data: String):
raw_data := file_link.read()
return AI_analyze(raw_data)
fn main():
# Create server instance that runs locally
server := AI_ProcessingServer()
# If you wanted to run it on an actual server you would add:
# link_to_server(server, “www.ai_processing.com”)
# Link to a specific file
data_file := File("data.txt")
link_to_file(data_file, "/path/to/data.txt")
# Process data from file using server
processed_data := server.process_data(data_file)
# Display the processed data
draw(processed_data)
Flogram prevents entire classes of commonly uncaught bugs in simple ways:
- Threading bugs
- Cross language bugs
- Memory safety bugs
- Shared state bugs
server BackendServer:
# Backend function for data processing. Type safety and memory safety are ensured.
fn processData(data: Array { I32 }) -> (result: Array { I32}):
# Processing data...
return sorted(data)
fn main():
# Frontend data initialization. Immutable by default, preventing shared state bugs.
frontendData := [5, 2, 8, 1]
# Connect to the server.
link_to_server(backend_server, backend.flogram.dev)
# Safe cross-language operation. Compile-time checks prevent threading and memory safety issues.
processedData := backend_server.processData(frontendData)
# Display processed data. Each iteration is isolated, avoiding threading issues.
foreach value at index in processedData:
display(value)
While being a very high-level simple language, Flogram is actually incredibly high-performance.
- The Flogram compiler uses automatic Rust-like ownership to increase the performance of your programs.
- Flogram heavily uses the stack over heap for memory management.
- Flogram is designed to reduce the cache and memory usage.
High-performance is strongly linked to energy efficiency as both involve doing more work with fewer operations. By using Flogram you can save costs, maximize battery life, and help the environment.
object Data:
value: I32
fn process(dataArray: Array { Data }) -> (processedArray: Array { Data}):
# Automatic ownership for objects, optimizing memory without manual effort
mut processedArray: Array { Data }(size = length(dataArray)) = []
foreach data in dataArray:
# Copy by value for efficient stack usage, reducing heap allocations
newValue: I32 = data.value * 2 # Simple operation for demonstration
newData: Data = Data(newValue)
processedArray = append(processedArray, newData)
# Compiler optimizations on object memory layout for enhanced performance
return processedArray
Flogram can create executables that can run websites or on Windows, Linux, Apple, or Android devices.
Flogram can call any javascript library or produce libraries that can be called with javascript. In the future, we hope to expand this to other languages.
Important Notice
Please be aware that Flogram is a work under progress 🔨 While we strive to bring you a full range of the features, some of them are not be available at this moment. We are committed to enhancing Flogram and are working tirelessly towards our complete vision. We appreciate your understanding and support as we continue to evolve and improve. Stay tuned for updates!
