Flogram

AI's languge of choice

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.

Loading...
01 ALL-IN-ONE LANGUAGE

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)

02 MINIMIZE BUGS
The Flogram language was designed to be able to catch as many non-logic bugs at compile time as theoretically possible. Including a couple that traditionally make it through the compiler like divide by zero errors. In scenarios where bugs can’t be caught at compile time we’ve strived to make them easy to fix.
Because Flogram is a full stack language, the compiler can catch bugs and you can use a debugger even across what would traditionally be separate languages. When you do something in the front end that could be a bug in the front end or backend or database, Flogram can know all the code that could contain that bug and feed all of it into the AI giving it a better chance of finding the bug.

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)

03 HIGH PERFORMANCE

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

04 CROSS-PLATFORM

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!

Our Inspiring Story

While working on a previous cryptocurrency project, Matt and his team faced challenges when using Rust's complicated and unfriendly language, largely due to it's problematic ownership tracking, which slowed down the... read story
discord-icon

Connect with the community

Feel free to ask questions, report issues, and meet new people.

Copyright © 2020 - 2024 Flogram LLC. All rights reserved.