Introducing Gcore FastEdge: Low-Latency Edge Computing for a Superior Developer Experience

Introducing Gcore FastEdge: Low-Latency Edge Computing for a Superior Developer Experience

We’re thrilled to unveil FastEdge, a lightweight edge computing solution that runs on our global Edge Network and delivers exceptional performance for serverless apps and scripts. FastEdge benefits developers by bringing computational power closer to the end user. Starting today, FastEdge is available in early beta with free access. In this article, we’ll share our reasons for creating FastEdge, explain the core technologies on which it’s built, and show you how it enhances user experience and makes developers’ lives easier.

Why We Built FastEdge

Imagine a news website delivering a personalized feed to each user, an e-commerce platform presenting a customized product selection based on user preferences and browsing history, or advanced image manipulation such as real-time watermarking. The growing demand for personalized, dynamic web content is outpacing traditional content delivery methods. This necessitates more sophisticated network solutions that handle computations close to the end user, accelerating dynamic content delivery to avoid lagging.

Content delivery networks (CDNs) have become an integral part of internet infrastructure—we’ve grown accustomed to fast web experiences, viewing them as a standard, and as we advance, there’s an increasing expectation for not only rapid, but also highly personalized, experiences, alongside the integration of emerging technologies like generative AI.

Traditional CDNs, while effective for static content delivery, often fall short in handling dynamic content. Traditional CDNs are unable to process and compute in real-time at the edge, so dynamic operations must be processed at the origin server, increasing response times.

This capability gap highlights the need for advanced edge computing solutions: Edge computing solutions will redefine the efficiency and responsiveness of dynamic content delivery by bringing computations closer to the user, and will bridge the gap left by traditional CDNs. Enter FastEdge.

FastEdge: WebAssembly Meets Serverless

FastEdge is an edge computing solution that harnesses the power of serverless computing and WebAssembly (Wasm) for efficient code execution on Gcore’s global CDN network. By integrating these technologies with Gcore’s Edge Network infrastructure, FastEdge significantly cuts the time from user request to response, leveraging the unique advantages of each component.

Serverless Computing

FastEdge is Gcore’s proprietary take on serverless computing. We, as the cloud provider, dynamically allocate machine resources and manage server operations for FastEdge users. This model offers several key advantages:

  • Faster development and deployment: Serverless computing allows developers to push code quickly and run it across a global network. This significantly shortens the time to market and fosters innovation in web app and service development.
  • Zero server provisioning: In a serverless environment, there’s no need for server provisioning or management. Developers can focus solely on their applications, with FastEdge efficiently handling the infrastructure. This shift enables greater focus on creativity and innovation, without the complexity of backend management.
  • Event-based pricing: Serverless computing often employs event-based pricing models. This pricing structure is particularly advantageous for businesses seeking efficient scaling and budget management; costs are directly tied to actual usage, making FastEdge cost-effective. (For now, FastEdge in free since it’s in early beta.)


At the heart of FastEdge lies WebAssembly runtime. WebAssembly (Wasm) is a binary instruction format, designed for executable programs. It provides software interfaces that enable these programs to interact with their host environment. Originally developed for client-side, in-browser computations, Wasm adapts well to cloud environment code execution.

Although it is still evolving and therefore has some limitations due to its relative novelty, Wasm offers several advantages:

  • Language flexibility: Wasm compiles from popular programming languages, so you can use JavaScript and Rust in FastEdge, with Go support coming soon. It’s a portable instruction format that’s efficient for both web and non-web environments, ideal for running computationally intensive tasks.
  • Fast cold start: Leveraging Wasm’s near-native performance, FastEdge can achieve an extremely fast cold start—as low as 0.5 ms.
  • Security: Applications in the Wasm runtime execute within a sandbox environment. This isolation benefits multi-tenant edge infrastructure by ensuring integrity and reducing shared environment risks. Thus, FastEdge ensures enhanced security for sensitive operations.
  • Performance: Wasm’s precompiled code eliminates the need for parsing, enabling execution speeds close to native performance. Its compact modules are highly efficient, making FastEdge particularly suitable for edge environments where resources might be limited.

Global Edge Network

FastEdge leverages Gcore’s worldwide Edge network as its infrastructure, significantly enhancing user experience and system efficiency.

  • Cloud-native scalability: Using Gcore’s network, FastEdge can seamlessly scale up or down based on the demand, which is essential for dynamic applications that experience variable user traffic.
  • Low latency: Gcore’s global network places services closer to users, minimizing latency. This proximity allows for smoother, more responsive user experiences tailored to individual needs.
  • Efficient deployment: The network’s robust architecture enables effortless code deployment across edge locations, minimizing latency and optimizing resource use.
  • Boosted reliability: Gcore’s ever-expanding network, currently boasting 160+ points of presence, further reduces latency and improves connectivity for all users, regardless of their location.

FastEdge combines the benefits of the multiple approaches and technologies upon which it is built. This significantly improves interactions between developers, users, and edge computing technologies, highlighting the powerful combination of Wasm and serverless computing on Gcore’s Edge Network.

How to Use FastEdge

Using FastEdge is straightforward:

  1. Code uploading: Upload code to the platform via the FastEdge API. We plan to make FastEdge available via Customer Portal GUI, CLI, and GitHub in the near future.
  2. Application deployment: Push your app to the FastEdge platform. It’s then automatically deployed across Gcore’s global network of edge servers.
  3. Traffic management: FastEdge natively routes and load balances your user traffic across its vast network. Requests are handled by the nearest available edge node for optimal performance and reliability.
  4. Code execution: When a user request hits the FastEdge network, the runtime executes your code and sends the HTTP response to the user.
A high-level view of FastEdge processing: code upload, app deployment, traffic management, and code execution upon user requests

There are two options for using FastEdge: with or without HTTP request/response modification.

Using FastEdge Without HTTP Response/Request Modification

Using FastEdge without HTTP request modification involves running functions directly on edge servers, allowing for improved speed and scalability: HTTP requests are handled by the edge network servers instead of the application’s web server. Essentially, edge servers function like origin servers, but they perform computations nearer to the end user.

FastEdge processing without HTTP request modification: upon request, the FastEdge server performs calculations and sends a response
FastEdge can be used to make calculations directly on the FastEdge server

The typical use cases for this kind of implementation are:

  • Quick authentication: Enhance your application’s security by swiftly validating secure tokens at the same edge, streamlining user access.
  • AI inference: Operate lightweight AI models on edge servers for responsive and intelligent AI applications.
  • URL rewrites and redirects: Manage your website traffic on the edge, reducing round-trip time.

Using FastEdge With HTTP Response/Request Modification

Using FastEdge with HTTP request modification allows you to manage and modify external requests. With this method, the FastEdge node acts as a proxy, forwarding or modifying requests to the relevant web server, API, or database. The FastEdge node receives the response, applies modifications as needed based on your function logic, and delivers it to the end user.

Diagram of HTTP request modification on FastEdge server
FastEdge can be used to modify requests dynamically before sending them to the user

FastEdge’s ability to handle HTTP request modification makes it a versatile tool for numerous edge computing applications. Typical use cases of this scenario include:

  • Personalization: Tailor your webpage content or notifications to align with user preferences like location, device type, or sign-in status for a more engaging experience.
  • A/B testing: Efficiently conduct and implement page tests by managing website traffic at the edge for real-time optimizations.
  • Advanced image editing: Use custom algorithms for image transformations beyond CDN capabilities, including format conversion and aesthetic adjustments.

Comparison: Wasm Runtime vs. Traditional FaaS

We offer two distinct serverless computing products: FastEdge with Wasm Runtime, and Gcore Function as a Service (FaaS) based on Linux containers. FastEdge and FaaS each offer unique advantages and disadvantages, making them suitable for different implementation scenarios.

FeatureFastEdgeFunction as a Service (FaaS)
Primary applicationFrontend web application optimizationBackend functions
Execution locations160+ locations25+ locations
EngineWebAssembly (Wasm) runtimeLinux container
Supported languagesRust, JavaScript (and Go, currently in development)Node.js, Python, Go, .NET, Java
Load balancingNative, CDN-basedRelies on multiple pods within a single region for load balancing
Maximum memory100 MB1028 MB and beyond
File System Access*NoYes**
Network AccessLimited, HTTP requests onlyYes
Resource provisioningNot requiredAutoscaling

* Both FastEdge and FaaS are designed for transient, stateless architecture for enhanced security and distributed computing efficiency. Any in-memory or local (in the case of FaaS) data are temporary and are deleted when function execution ends.

** FaaS permits secure, temporary file access through mechanisms like object storage and network file systems for isolated function execution.

FastEdge is ideal for frontend applications due to its low latency and smaller app size. It excels at quick delivery tasks and computational activities like lightweight AI inference or real-time image manipulation.

In contrast, FaaS is better suited for complex backend tasks. It supports larger packages and provides file system and network access, making it a better fit for jobs requiring substantial computational resources and integrations, such as video transcoding or complex business logic computations.

Join the FastEdge Beta Program

FastEdge is currently in its early beta phase, and we warmly invite you to join this exciting journey. To join the beta program, simply sign up for Gcore and generate a FastEdge API key.You can start creating FastEdge apps right away.

During the beta period, FastEdge is completely free to use. This is a great opportunity to explore its capabilities and understand how it can benefit your projects, without any financial commitment.

We’d love to hear about your experience with FastEdge. Your feedback and use cases will play a crucial role in shaping the future of this innovative platform.

Note: During its early beta stage, FastEdge is best suited for exploratory and developmental purposes. We recommend not using it for mission-critical tasks or production environments until the beta phase concludes. Also, keep in mind that during the beta, FastEdge comes with certain limitations.


FastEdge is a groundbreaking advancement in edge computing, offering a unique combination of speed, efficiency, and flexibility. By harnessing the power of WebAssembly and serverless computing within Gcore’s expansive global network, FastEdge is set to revolutionize how developers handle dynamic content and complex computational tasks, bringing them closer than ever to the end user.

This early beta phase is an invitation to explore the untapped potential of FastEdge. FastEdge provides a robust platform to build on, whether for quick content personalization, AI-driven solutions, or efficient content delivery. We encourage you to join the beta program, experiment with its capabilities, and contribute to its evolution with your valuable feedback.

Create an Account and Join the FastEdge Beta Program Now!

Subscribe to our newsletter

Stay informed about the latest updates, news, and insights.