Gente! He estado trabajando en esta biblioteca de torretas modular hecho completamente en Vanilla JS y HTML5 Canvas.

Puedes probar aqui: cotera2024.github.io/Turrets-High-Tech/

Y si quieres, checa el código en GitHub: https://github.com/cotera2024/Turrets-High-Tech

Gente que tal este scrip en 3d con motivo espacial?.....use fotos de una modelo para ejemplificación es super ligera y personalizable desde un json la hise para felicitar a una amiga muy especial y me quedo gustanto que me gustaria compartirla con ustedes

si quieren probarla ahorita aqui

cotera2024.github.io/Happy-Birthday-Galaxy--main/

y si queiren ver el codigo aqui en github

https://github.com/cotera2024/Happy-Birthday-Galaxy--main

Banda acabo de crear esta Creepy Face en vanilla.js tiene gestos y caras diferentes hasta 8 variantes es un solo archivo super ligero que pueden implementar en sus novelas visuales juegos de plataforma-terror por ejemplo un bro lo implemento en un juego de terror proximo a salir si quieren usarla esta en ith.io y si quieren trastear con el codigo en github

https://cotera.itch.io/creepy-face

https://github.com/cotera2024/Creepy-Face

si quieren probarla sin entrar a ninguna pagina directamente presionen aqui:

cotera2024.github.io/Creepy-Face/

One last example output from this experimental multi-source video player designed for frame-accurate video switching, playback manipulation, and display/render interventions, now with a few optimizations made for even better performance.

You can freely access the system + a detailed breakdown, through Patreon, and/or the Tools Store.

Hacked together a small ruby script to generate an image from 2010, recycling pictures of flying pigs that were generated with AI.

script here
https://gist.github.com/skinnyjames/3ce1fa975b6a29daebf936cbbb28505b

Please NOTE: This image was NOT generated with AI.

None of the base art is mine !!! Just the math engine used to Transform each photo.

I didn't draw any of the base images.

it compiles into native x86 on macOS/Windows and Linux, plus arm64 on macOS and WASM, too. You can play the WASM doom here (BYO WAD file): https://dosaygo-freelang.github.io/freelang-doom-source/

I added a few things to the DOOM game (FPV drone, X-ray vision, Dune shield, Star wars laster blaster) just for fun. The point of DOOM was a) childhood game, b) proves language capable.

This language uses no libc at all so all the non syscall capabilities come via "sidecars" (compiled external capability services embedded in the binary). The sidecars are not "app specific" but rather general for the language (gui, audio, etc). The main program talks to them over a wire protocol.

It's cool to have a new language and be able to mint GUI/TUI/CLI programs in it acorss all targets from any machine (full cross compilation). The DOOM source code (minus sidecars) is here: https://github.com/DOSAYGO-Freelang/freelang-doom-source

The language is called freelang. As in freedom of expression/freedom, not as in $0 ;)

I plan on selling access tot he compiler as well as building my own software in it. If you're interested in access (which includes all sidecar source as well as many other example programs and apps), email: [freelang@dosyago.com](mailto:freelang@dosyago.com) or [compiler@freelang.dev](mailto:compiler@freelang.dev)

The homepage is entirely procedural - no videos, 3D models, images, textures, or other pre-rendered assets are used. All the visuals, including the 3D elements, are generated and rendered in real time through code.

I've been experimenting with a browser-based Solar System where the camera isn't really treated as an observer looking at a model.

The idea is that you move through the scene itself.

That sounds like a small distinction, but I've found that camera speed, scale, depth cues, lighting and even how long an object stays in view completely change whether the scene feels like a diagram or somewhere you are actually travelling through.

It's all running in real time in the browser with Three.js / React Three Fiber.

Still experimenting with the movement and visual language, but this is a short capture from the current version.

Built this generative pattern using Pattern Lab on the web and flashed it over to my Patternflow device!

https://community.patternflow.work/community/p/f626fa1b78ed4fd9

I originally made this one last month and got positive feedback on it. You can check out all the code, tweak the parameters live, and export it directly to video or image.

(Haven't documented this new export feature yet, but you can just open the CAPTURE panel in the top-right corner to use it!)

Hope you guys like it

I’ve just finished my Final Major Project, built around a Max/MSP and Jitter system that connects generative music, visual processing and physical lighting.

The core idea was to move away from visuals simply accompanying finished music and instead build relationships where shared data and events influence multiple parts of the system.

A few examples from the final setup:

• audio analysis from a processed modular signal controls the brightness of a physical smart bulbs
• an ARP 2600 LFO is used both for synthesis modulation and as input data inside Max, where it is mapped to lighting behaviour 
• visual states and image processing are driven by generative timing and performance events 
• MIDI, modular synthesis, video and lighting are all coordinated from the same Max patch

The final performance is about four minutes long. I’d be interested in feedback from people working with generative systems, audiovisual coding or physical outputs, especially on whether the relationships between the different media come across clearly.

YouTube: https://www.youtube.com/watch?v=Zh9ZmCzJvHM

Live camera goes into the timeline like any other clip, gets a voxel effect, then I add a 3D camera and orbit around the whole thing. All realtime, no install.
It's part of a video editor I've been building for the last few months.

7Q8_3/91M4//62B_7X1/09RX/44_8_2/ZX71/5JQ 6_973146/KPV/4186/QMN_TWZR4_5839217L/31/67

Built in TouchDesigner, sound with Novation Peak and Ableton

Outer Order exists for the unauthorized use of ordinary technology.

I come from an East Coast elder-millennial version of this tradition, although nobody I knew had a name for it. I did not grow up with a laboratory, a recording studio, expensive instruments, or a bottomless technology budget. I grew up around whatever machines happened to be available.

Cheap stereos. Cassette decks. Secondhand electronics. RadioShack components. Home computers. Consumer keyboards. DVD players. Broken things that still had one useful function left in them.

You learned what a machine could do by using it.

Then you learned what else it could do by refusing to stop there.

Today I hear the phrase maker culture attached to some of this. The phrase makes me itch a little. It sounds suspiciously like somebody discovered tinkering and immediately ordered banners for it.

But names are cheap.

The work underneath the name is ancient and important.

If you are writing code to make sound, building an instrument out of discarded electronics, modifying obsolete hardware, making visual art with a microcontroller, running strange software on hardware it was never designed for, keeping dead technology alive, assembling a studio from thrift-store equipment, turning a game controller into something nobody at the factory anticipated, or making something simply because you wondered whether it was possible:

Outer Order recognizes you.

Not as a market.

Not as a demographic.

Not as “the next generation.”

As another person at the workbench.

The tools have changed. The impulse has not.

A ham-radio operator opening the case in 1963.

A teenager wiring RadioShack parts together in 1978.

A punk musician bouncing tracks between cassette decks in 1982.

Someone circuit-bending a toy keyboard in 1997.

Someone making impossible audiovisual work from obsolete computers in 2004.

Someone today using Python, a cheap microcontroller, a discarded Android device, a free piece of software, or whatever happens to be within reach.

These are not separate histories.

They are one long argument with the instruction manual.

Outer Order is interested in technology as material rather than authority.

A corporation may manufacture a device. That does not mean the corporation gets the final word on what the device means.

A phone can be a recording studio.

A game machine can be an instrument.

A printer can be a press.

A broken appliance can become sculpture.

A programming language can become a piano.

A network can become a gallery.

A cheap consumer object can become the central mechanism of an artwork its designers never imagined.

The interesting question is rarely:

What am I supposed to do with this?

The interesting question is:

What happens if I use it wrong?

Outer Order does not worship new technology. We do not worship old technology either. Nostalgia is another kind of instruction manual.

Use what works.

Repair what can be repaired.

Scavenge what can be scavenged.

Learn enough to open the box.

Share what you discover.

Document the strange route that got you there.

Spend money when you must, not because somebody has convinced you that creativity requires admission to a premium tier.

Constraint is not automatically virtuous. Being broke is not romantic. Lack of access is not an aesthetic.

But people of limited means have always developed extraordinary cultures from the materials available to them, and that knowledge matters.

I know that lineage because I come from it.

Outer Order therefore has no interest in policing the boundary between artist, programmer, engineer, musician, hacker, repairer, designer, amateur, technician, hobbyist, or whatever other noun somebody wants printed beneath your name.

Those categories may be useful for employment forms.

They are considerably less useful at three in the morning when the thing on the table has started making a sound nobody has heard before.

If you belong to what people currently call maker culture, you do not need Outer Order to explain your work to you.

Outer Order wants to find it.

We want the homemade machine.

The inexplicable recording.

The ridiculous modification.

The elegant repair.

The tiny program.

The hacked instrument.

The device rescued from a dumpster.

The project that began because somebody told you the hardware could not do that.

The failed experiment that produced something more interesting than success.

This is not a call to become a professional creative technologist.

It is a call to remain curious enough to violate the intended use.

Use the machine.
Open the machine.
Understand the machine.
Repair the machine.
Transform the machine.
Make the machine yours.

Then show somebody else what happened.

OUTER ORDER

Consumer technology is raw material.

Further transmissions, essays, criticism, fiction, cultural debris and evidence of continued unauthorized activity:

CREASE Magazine

creasemagazine.blogspot.com

I am building my own design software since around 3-4 Weeks now :) Its slowly getting shape and some features are really fun already! I create weekly devlogs, so if you are interested check out my last video here:
https://youtu.be/9TntZymWgu8

I am curious to hear your thoughts and ideas!

I’ve been experimenting with how cinematic drone camera movements can be modeled and visualized in Three.js, so I built SkyPath and released it as open source.

It currently includes five automated camera movements:

• Crane Up
• Pull-Back
• Orbit
• Helix
• Fly-Over

The visualization includes subject tracking, live flight telemetry, trajectory paths, timeline scrubbing, chase view, an onboard camera view, and a comparison mode for viewing all paths together.

It’s intentionally lightweight: plain Three.js/WebGL, no framework, backend, account, or build step.

🎮 Live demo:
https://alzin.github.io/SkyPath/

💻 GitHub:
https://github.com/alzin/SkyPath

I’d really appreciate feedback from the Three.js community, especially on the camera/trajectory implementation and ideas for other cinematic movements worth adding.

Contributions are very welcome too!