Skip to main content
.NET 10 Performance

Logic Without Limits.
C# at the Edge.

Break free from restrictive "No-Code" blocks. Write high-performance, zero-allocation C# scripts directly in your browser and deploy them to thousands of Edge Gateways instantly.

Why C# at the edge?

Some logic is too specific for drag-and-drop. Proxus lets you run high-performance C# functions right next to the machines, with zero-allocation patterns and managed safety guards.

  • Sub-millisecond execution for critical edge logic.
  • Sandboxed—restricted APIs, controlled resources, governed execution.
  • UNS-native—subscribe to normalized topics; no duplicate tag dictionaries.
  • Deploy once, scale everywhere—ship the same function to many gateways.

Guardrails

  • Read-only unless you explicitly allow writes
  • Execution limits to prevent runaway scripts
  • Safe APIs; no direct low-level access to PLCs
  • Auditable deployments and runs
Custom logic without sacrificing stability or safety.
1using Proxus.SDK;
2
3public class AnomalyDetector : FunctionBase
4 public override async ValueTask Handle(Message msg)
5 // Calculate Moving Average (Zero Allocation)
6 var value = msg.Payload.GetDouble("temp");
7 if (value > 85.0)
8 Logger.Warning($"Critical Temp: {value}");
9 await Output.EmitAsync("alerts", msg);
10
11
12

How it works

Write C# once, ship it to edge gateways. Functions subscribe to UNS topics, process data, and emit results or alerts—under resource and safety constraints.

  1. Write/extend a function with C# (.NET 10).
  2. Subscribe to normalized UNS topics; no custom tag maps per site.
  3. Deploy to one or many gateways; run close to the data.
  4. Emit outputs to UNS topics or alerts; keep control writes gated.
  5. Monitor execution, exceptions, and performance.

What you can build

  • Custom anomaly detectors and SPC checks
  • Protocol translations and payload shaping
  • Inline aggregations (rollups, min/max/avg)
  • Advanced routing and enrichment before storage
Deploy the same function across plants—reuse UNS topics and templates.

Safety and governance

Edge code is powerful—Proxus keeps it contained with strict permissions, resource limits, and auditability.

  • Sandboxed execution with restricted APIs.
  • Resource limits to avoid runaway memory/CPU.
  • Audit trails for deployments and execution outcomes.

Best practices

  • Use zero-allocation patterns and pooling
  • Keep writes gated; prefer read/emit flows
  • Reuse UNS tags; avoid custom tag dictionaries
  • Log clearly and monitor performance

FAQ

Common questions on safety, performance, and deployment.

Can edge code write to control?

Only if you allow it. Default is read/emit; writes are governed and optional.

How do we prevent runaway scripts?

Resource limits and restricted APIs keep functions safe; executions are monitored.

Do we need separate tag models per site?

No. Subscribe to normalized UNS topics; reuse the same code across plants.

How fast can it run?

Designed for sub-millisecond execution on the edge with zero-allocation patterns.

Ready to ship C# to the edge safely?

Deploy custom logic to gateways, reuse UNS tags, and keep control writes governed.

See Developer Scripting Guide Learn How Edge Executes Your Code