u/nycgio

Kanvon.com Now supports 2D meshes to create animations, could easily animate with using lua scripting to follow a specific object

Game Title: Orbit Bloom

Playable Link: https://www.kanvon.com/scene/orbit-bloom

Platform: Web

Description: A board of concentric rings, each one loaded with symbols. Press a ring, drag around the centre to spin it, and let go to commit. Line up three of a kind pointing at the core and they launch inward; everything behind them falls in and the rim refills, so a single turn can run away into a cascade.

Free to Play Status:

• [ x] Free to play
• [ ] Demo/Key available
• [ ] Paid (Allowed only on Tuesdays with [TT] in the title)

Involvement: Everything

Been working on this 2D engine for 2 years and i created some interesting projects to test the performance of the rendering pipeline. But i didn't create a full working game till now!

This is a puzzle game that allows you to turn disks to match shapes colors. Some feedback would be great! is it fun? use your mouse. https://www.kanvon.com/scene/orbit-bloom

Here we are showcasing how we can use kanvon to script with lua and create visual/sound effects. Showcasing some Algorithms!

Engine supports physics and much more! remember happy wheels?

try it out https://www.kanvon.com/scene/happy-ragdoll

toolset: https://www.kanvon.com/editor?example=physics-sandbox

Kanvon just shipped the two features that turn it into something closer to a little game engine. A built-in Lua scripting layer and a custom 2D rigid-body physics engine.

The physics is all custom, no engine dependency. SAT collision detection, sequential-impulse solver with warm starting, convex polygons + circles, and concave paths auto-decomposed into colliders. Scripting is Lua.

Kanvon is a 2d engine that allows you to create many things. This example is a 2d platformer. The game logic is written in lua and runs at runtime. No compiling. Beat my score 46:43 :p

https://www.kanvon.com/scene/physics-platformer

Kanvon is a vector + raster editor that runs entirely in your browser — real GLSL shaders, GPU effects, animation, auto-layout, and live collaboration, all on a Rust/WebGL engine. No install, no signup. The whole point is that you don't have to choose between designing and coding: you can draw a shape, drop a shader on it, script it in Lua, or lay it out with a real CSS box model, without ever leaving the canvas.

This video is a quick tour of a few example scenes. Everything you're seeing is the live engine rendering in real time — not screen recordings of something pre-baked.

Lua Solar System - https://www.kanvon.com/editor?example=lua-solar-system

It's a little planetary system where every planet is driven by its own Lua script — each one animates its own transform on its own timeline, completely independent of the main timeline. So the orbits just run on their own clocks, generative, no keyframes. And then on top of that scripted motion, you can still grab parameters and keyframe them on the main timeline. Per-shape scripts run every frame inside a fuel-budgeted VM, so the framerate stays safe no matter what you write.

Pendulum Wave - https://www.kanvon.com/editor?example=pendulum-wave

A classic pendulum-wave pattern. The number of pendulums is keyframed. I animate the count itself on the timeline and watch the wave build up and drift in and out of phase as the shapes multiply.

Website Design - https://www.kanvon.com/editor?example=website-design

A totally different side of the tool — a web page laid out with Box Sizing, which brings the real CSS box model to the canvas: flexbox, grid, margins, padding, borders.

Quantum Vortex - https://www.kanvon.com/editor?example=quantum-vortex

Closing on a shader. The whole effect is built in the visual node graph — no hand-written GLSL — and it compiles down to a real fragment shader running live on the shape's fill. If you'd rather type it out, you can drop into actual GLSL code at any point; the graph and the code are two views of the same thing.

Community - https://www.kanvon.com/community/hot

you can also join the community and upload your own work

Here is a tutorial on a Fractal Tunnel Shader Tutorial

#float speed 0.5 0.1 2.0
#float zoom  2.0 0.5 5.0
#float twist 3.0 0.0 10.0
#color color1 #ff3366
#color color2 #3366ff
#color color3 #33ff66

void main() {
    vec2 uv = v_uv * 2.0 - 1.0;
    uv.x *= u_resolution.x / u_resolution.y;

    float t = u_time * speed;
    float r = length(uv);
    float a = atan(uv.y, uv.x);

    float tunnel = 1.0 / (r + 0.1);
    float angle  = a + tunnel * twist + t;

    float pattern = 0.0;
    for (int i = 0; i < 4; i++) {
        float fi = float(i);
        float scale = zoom * (1.0 + fi * 0.5);
        float wave  = sin(tunnel * scale - t * (1.0 + fi * 0.2));
        wave       += sin(angle * (3.0 + fi) + t);
        pattern    += wave / (2.0 + fi);
    }
    pattern = pattern * 0.5 + 0.5;

    vec3 color = mix(color1, color2, sin(pattern * PI) * 0.5 + 0.5);
    color = mix(color, color3, sin(pattern * 6.28318 + t) * 0.5 + 0.5);
    color *= 1.0 - r * 0.5;

    fragColor = vec4(color, u_opacity);
}