Row

Game dev.
BTC Maximalist.
Learning to Sail.

Public Key

npub1u3svk99639mcdfn43s2nawg4a2j4ejmgrq2n63l4t67wzqdmtnks2uxaql

NIP-57 Address

rowboto@lawallet.ar

Profile Code

nprofile1qqswgcxtzjagjaux5e6cc9f7hy274f2ued5ps9fagl64a08pqxa4emgpzemhxue69uhhyetvv9ujumn0wd68ytnzv9hxgqgcwaehxw309aex2mrp0yh8xmn0wf6zuum0vd5kzmqhensjk

Publishing to

relay.nostr.band

relay.snort.social

Author Public Key

npub1u3svk99639mcdfn43s2nawg4a2j4ejmgrq2n63l4t67wzqdmtnks2uxaql

Show more details

Last Notes

2025-01-12 09:39:00

- reply

Also OpenBSD is amazing.
Simple, efficient, reliable, philosophically correct.
If only I could run Docker with linux images efficiently it would be my main system.

2025-01-12 09:34:28

- reply

It's GLSL, GPU shader code. Try the link!
Today I'm posting a long-form note explaining this weird stuff and what I intend to do.

2025-01-12 01:03:25

- reply

I completely agree 😄.
Well, the fire poker argument was on absolute ethical norms: Popper said there were, LVW said that there weren’t.
So by what you’re saying you’re pretty much already aware of how it went: Popper trolled Wittgenstein, and he got (reasonably) mad and stormed away. Which is a win in my eyes, since Popper was not intending to collaborate, just doing silly nit-picking.
Knowledge (scientific or not) requires a priori assumptions, denying that not all valuable information comes from reasoning is… silly in itself... and easily falsified.

2025-01-11 23:29:47

- reply

Ruth is giving me too much credit, I just provided the “tolerance paradox” concept by Popper.
Empiricists are based by definition, meaning only those that do not deviate from Popper’s falsification method, then of course their view on statism may be just contradictions and biases.
But I very much think that Ludwig Wittgenstein actually won the famous “fire poker” argument against Popper.

2025-01-11 16:48:16

- reply

What did he do now?
I mean besides sucking some serious CIA dick.

2025-01-09 20:22:36

- reply

Amerikuka con YESGIVE.

2025-01-09 14:12:47

- reply

I see, you’d need a pc or laptop to act as proxy/tunnel for my solution to work.

2025-01-09 13:44:01

- reply

Also: if you use an ssh tunnel through any well known port you’re not getting caught. Ssh is fully encrypted, no one can see that traffic, except that it’s ssh going through a port.
Worst case scenario: “oh yeah I was testing my home ssh proxy, I’m an infosec enthusiast tee-hee, just sending cute cat pictures, don’t mind me”.

2025-01-09 13:39:57

- reply

I’m not a bitaxe expert, but how’s the setup?
Assuming:
(you)A—fw—internet—B(bitaxe)
If you have access to an ssh server from A, and that server can connect to B, you can always go through any open port in fw to the ssh server, and open a tunnel through it to B.
Fuck that firewall.

2025-01-09 13:32:23

- reply

Anda bien 😎.
Voy a preparar un long-form note con unas ideas que charlamos con @npub19tv…x4xe.
Kind existente o propuesta, interop con los clientes, formato del nevent, editabilidad, etc.
En su forma actual #glostr es spam, así que hay que salvarlo de eso.

2025-01-09 12:06:10

- reply

#hola buenos días muchachos. ☕️

2025-01-07 21:28:27

This one is all mine SDF+Raymarching+Raytracing.
[ Sorry for turning your GPU into a stove ]
You can watch this at #glostr:
https://rowdaboat.github.io/glostr/#npub1u3svk99639mcdfn43s2nawg4a2j4ejmgrq2n63l4t67wzqdmtnks2uxaql
```glsl
#version 300 es
precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
out vec4 fragColor;
#define MAXDISTANCE 180.
#define EPSILON 0.001
#define TENTH_EPSILON 0.0001
float time;
///////////////
// Structures
struct Camera {
vec3 position;
vec3 direction;
vec3 up;
vec3 left;
vec2 resolution;
};
struct Ray {
vec3 origin;
vec3 direction;
};
#define SKYBOX 0
#define GEOMETRY 1
struct Material {
vec3 color;
vec3 emissive;
float roughness;
};
struct Hit {
vec3 point;
float distance;
vec3 normal;
Material material;
};
/////////////
// Material
Material material(vec3 color, vec3 emissive, float roughness) {
Material material;
material.color = color;
material.emissive = emissive;
material.roughness = roughness;
return material;
}
/////////////
// Ray Hits
Hit noHit() {
Hit hit;
hit.distance = .0;
hit.material.emissive = vec3(0, 0, 0);
hit.material.color = vec3(1, 1, 1);
hit.material.roughness = 1.;
return hit;
}
///////////
// Random
vec4 random;
void shuffle() {
random = fract(1e4 * sin(random) + random.wxyz + 0.5);
}
void initRandom(vec2 normalizedPixel, float frame) {
random = vec4(normalizedPixel, frame, 1);
for(int i = 0; i < 16; i++)
shuffle();
}
////////////////////////
// Viewport and Camera
vec2 viewport(vec2 coordinate, vec2 resolution) {
vec2 normalized = coordinate.xy / resolution.xy;
vec2 centered = -1.0 + 2.0 * normalized;
float aspectRatio = resolution.x / resolution.y;
return vec2(centered.x * aspectRatio, centered.y);
}
Camera camera(vec3 position, vec3 target, float roll, vec2 resolution) {
Camera camera;
camera.position = position;
camera.direction = normalize(target - position);
vec3 rolling = vec3(sin(roll), cos(roll), .0);
camera.up = normalize(cross(camera.direction, rolling));
camera.left = normalize(cross(camera.up, camera.direction));
camera.resolution = resolution;
return camera;
}
Ray cameraRay(Camera camera, vec2 point) {
vec2 displacedPoint = point + random.xy / (0.5 * camera.resolution.xy);
vec3 displacement =
displacedPoint.x * camera.up +
displacedPoint.y * camera.left;
Ray ray;
ray.origin = camera.position;
ray.direction = normalize(displacement + 1.5 * camera.direction);
return ray;
}
#define SAMPLES 15
#define BOUNCES 4
#define MAX_STEPS 25
//////////////////////////
// SDF Scene
float smoothMin(float d1, float d2, float k) {
float h = max(k - abs(d1 - d2), 0.0) / k;
return min(d1, d2) - h * h * h * k * (1.0 / 6.0);
}
float box(vec3 p, vec3 b) {
vec3 q = abs(p) - b;
return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
}
float cylinder(vec3 p, float h, float r) {
vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(r,h);
return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float coin(vec3 point) {
float base = cylinder(point, .1, 1.);
float coinCarve = cylinder(point + vec3(0., -.54, 0.), .5, .9);
float lbar = box(point + vec3(.125, 0., 0.), vec3(.06, .09, .75));
float rbar = box(point + vec3(-.125, 0., 0.), vec3(.06, .09, .75));
float back = box(point + vec3(.1, 0., 0.), vec3(.3, .09, .6));
float bars = min(lbar, rbar);
float tbelly = cylinder(point + vec3(-.175, 0, 0.25), .09, .35);
float bbelly = cylinder(point + vec3(-.175, 0, -.25), .09, .35);
float bellies = min(tbelly, bbelly);
float b = min(min(back, bars), bellies);
float carveTBelly = cylinder(point + vec3(-.175, 0, 0.25), 1., .175);
float carveBBelly = cylinder(point + vec3(-.175, 0, -.25), 1., .175);
float carveTBox = box(point + vec3(-.05, 0, 0.25), vec3(.1, 1, .175));
float carveBBox = box(point + vec3(-.05, 0, -.25), vec3(.1, 1, .175));
float bellyCarving = min(min(carveTBelly, carveBBelly), min(carveTBox, carveBBox));
float backCarving = box(point + vec3(.5, 0, 0), vec3(.25, 1, .45));
float carve = min(bellyCarving, backCarving);
float carvedB = max(b, -carve);
return min(max(base, -coinCarve), carvedB);
}
float moon(vec3 point) {
float time = u_time * 2.0;
return length(point - vec3(1.5, 2.5, -1.6 + .125 * sin(time))) - 1.75;
}
float orbiter(vec3 point) {
float time = u_time * .5;
vec3 position = vec3(.9 * sin(time), -0.25, .9 * cos(time));
return length(point + position) - 0.25;
}
float sdfScene(vec3 point) {
float time = u_time * 2.0;
float coin = coin(point);
float moon = moon(point);
float orbiter = orbiter(point);
return min(coin, min(moon, orbiter));
}
Material sdfTagMaterial(Ray ray, float distance, vec3 point) {
float time = u_time * 2.0;
Material result;
float coin = coin(point);
float moon = moon(point);
float orbiter = orbiter(point);
if (abs(moon) <= EPSILON) {
// Light
result = material(
vec3(.6, .6, 1),
vec3(1.2, 1.2, 1.2),
.55
);
} else if (abs(orbiter) <= EPSILON) {
// Orbiter
result = material(
vec3(.3, 0.2, 0.6),
vec3(2, 2, 2),
1.
);
} else if (abs(coin) < EPSILON) {
// Gold
result = material(
vec3(.95, .7, .45),
vec3(.0),
.2
);
} else {
// Skybox
result = material(
(.9 + .125 * sin(time * 0.5)) * 1.4 * mix(vec3(.25, .125, .125), vec3(.7, .8, 1), .5 + .5 * ray.direction.y),
vec3(1, 1, 1),
1.0
);
}
return result;
}
////////////////////////////////////////////////
// Main tracing + marching loop
// Bounces, diffuse, emission, and reflections
vec3 cosineWeightedRandomHemisphereDirection(const vec3 n) {
vec3 uu = normalize(cross(n, vec3(0.0, 1.0, 1.0)));
vec3 vv = cross(uu, n);
float ra = sqrt(random.y);
float rb = 6.2831 * random.x;
float rx = ra * cos(rb);
float ry = ra * sin(rb);
float rz = sqrt( 1.0 - random.y);
vec3 rr = vec3( rx * uu + ry * vv + rz * n );
return normalize(rr);
}
vec3 computeNormal(vec3 point) {
vec3 epsilon = vec3(EPSILON, 0.0, 0.0);
float dx = sdfScene(point + epsilon.xyy) - sdfScene(point - epsilon.xyy);
float dy = sdfScene(point + epsilon.yxy) - sdfScene(point - epsilon.yxy);
float dz = sdfScene(point + epsilon.yyx) - sdfScene(point - epsilon.yyx);
return normalize(vec3(dx, dy, dz));
}
Hit march(Ray ray) {
Hit hit = noHit();
for(int i = 0; i < MAX_STEPS; i++) {
vec3 pivot = ray.origin + ray.direction * hit.distance;
float distance = sdfScene(pivot);
hit.distance += distance;
if(hit.distance > MAXDISTANCE || distance < .1 * TENTH_EPSILON) break;
}
hit.point += ray.origin + ray.direction * hit.distance;
hit.normal = computeNormal(hit.point);
hit.material = sdfTagMaterial(ray, hit.distance, hit.point);
return hit;
}
vec3 bounces(Ray ray) {
Hit hit = noHit();
vec3 absortion[BOUNCES];
vec3 emission[BOUNCES];
int i = 0;
for(i = 0; i < BOUNCES - 1 && hit.distance < MAXDISTANCE; i++) {
shuffle();
//hit = trace(ray);
hit = march(ray);
vec3 diffuse = cosineWeightedRandomHemisphereDirection(hit.normal);
vec3 reflection = reflect(ray.direction, hit.normal);
ray.direction = mix(reflection, diffuse, hit.material.roughness);
ray.origin = hit.point + EPSILON * ray.direction;
emission[i] = hit.material.emissive;
absortion[i] = hit.material.color;
}
vec3 sampled = vec3(0);
for (; i > 0; i--) {
sampled += emission[i - 1];
sampled *= absortion[i - 1];
}
return sampled;
}
void main() {
time = u_time;
initRandom(gl_FragCoord.xy, time);
vec2 viewportPoint = viewport(gl_FragCoord.xy, u_resolution.xy);
vec2 cameraWobble = vec2(
.1 * cos(time * 1.2),
.1 * sin(time * 1.2) + 1.5
);
Camera camera = camera(
vec3(cameraWobble, 2), // position
vec3(0, 0.2, 0.), // target
0.05 * cos(time * 1.2), // roll
u_resolution.xy
);
vec3 color = vec3(0.);
for(int j = 0; j < SAMPLES; j++) {
shuffle();
Ray ray = cameraRay(camera, viewportPoint);
color += bounces(ray);
}
fragColor = vec4(color / float(SAMPLES), 1.0);
}
```

2025-01-07 07:31:48

Fourth and last for now, it's late and I'm sleepy, been coding all day.
I'm happy #glostr is working 😄, and that I learned a bit more of how #nostr works. So powerful.
```glsl
#version 300 es
precision mediump float;
// Original shader:
// Starfield by totetematt
// www.shadertoy.com/view/lcjGWV
uniform vec2 u_resolution;
uniform float u_time;
out vec4 fragColor;
struct Grid {
vec3 id;
float d;
} gr;
#define FBI floatBitsToInt
#define FFBI(a) FBI(cos(a))^FBI(a)
float hash(vec3 uv) {
int x = FFBI(uv.x);
int y = FFBI(uv.y);
int z = FFBI(uv.z);
return float((x * x + y) * (y * y - x) * (z * z + x)) / 2.14e9;
}
void dogrid(vec3 ro, vec3 rd, float size) {
gr.id = (floor(ro + rd * 1E-3) / size + .5) * size;
vec3 src = -(ro - gr.id) / rd;
vec3 dst = abs(.5 * size) / rd;
vec3 bz = src + dst;
gr.d = min(bz.x, min(bz.y, bz.z));
}
vec3 erot(vec3 p, vec3 ax, float t) {
return mix(dot(ax, p) * ax, p, cos(t)) + cross(ax, p) * sin(t);
}
void main() {
vec2 uv = (gl_FragCoord.xy - .5 * u_resolution.xy) / u_resolution.y;
vec3 col = vec3(0.);
vec3 ro = vec3(0.2, 0.2, -5.), rt = vec3(0.);
vec3 z = normalize(rt - ro);
vec3 x = normalize(cross(z, vec3(0., -1., 0.)));
vec3 y = cross(z, x);
vec3 rd = mat3(x, y, z) * normalize(
vec3(uv, 2. + tanh(hash(uv.xyy + u_time) * .5 + 10. * sin(u_time)))
);
float i, e, g;
float gridlen = 0.;
for(i = 0., e = .01, g = 0.; i++<99.;) {
vec3 p = ro + rd * g;
vec3 oop = p;
p = erot(
p,
normalize(sin(u_time * .33 + vec3(.6, .4, .2))), u_time * .2
);
p.z += u_time;
vec3 op = p;
if (gridlen <= g) {
dogrid(p, rd, 1.);
gridlen += gr.d;
}
p -= gr.id;
float gy = dot(sin(gr.id * 2.), cos(gr.id.zxy * 5.));
float rn = hash(gr.id + floor(u_time));
p.x += sin(rn) * .25;
float h = rn > .0 ? .5 : length(p) - .01 - gy * .05 + rn * .02;
g += e = max(.001+op.z*.000002, abs(h));
col += vec3(.25, .25, 1. + abs(rn)) *
(0.025 + (.02 * exp(5. * fract(gy + u_time)))) /
exp(e * e * i);
}
col *= exp(-.08 * g);
fragColor = vec4(sqrt(col), 1.0);
}
```

2025-01-07 07:24:43

MOAR #glostr
https://rowdaboat.github.io/glostr/#npub1u3svk99639mcdfn43s2nawg4a2j4ejmgrq2n63l4t67wzqdmtnks2uxaql
```glsl
#version 300 es
precision mediump float;
// Original shader:
// Cyber Fuji by kaiware007
// www.shadertoy.com/view/Wt33Wf
uniform vec2 u_resolution;
uniform float u_time;
out vec4 fragColor;
float sun(vec2 uv, float battery)
{
float val = smoothstep(0.3, 0.29, length(uv));
float bloom = smoothstep(0.7, 0.0, length(uv));
float cut = 3.0 * sin((uv.y + u_time * 0.2 * (battery + 0.02)) * 100.0)
+ clamp(uv.y * 14.0 + 1.0, -6.0, 6.0);
cut = clamp(cut, 0.0, 1.0);
return clamp(val * cut, 0.0, 1.0) + bloom * 0.6;
}
float grid(vec2 uv, float battery)
{
vec2 size = vec2(uv.y, uv.y * uv.y * 0.2) * 0.01;
uv += vec2(0.0, u_time * 4.0 * (battery + 0.05));
uv = abs(fract(uv) - 0.5);
vec2 lines = smoothstep(size, vec2(0.0), uv);
lines += smoothstep(size * 5.0, vec2(0.0), uv) * 0.4 * battery;
return clamp(lines.x + lines.y, 0.0, 3.0);
}
float dot2(in vec2 v ) { return dot(v,v); }
float sdTrapezoid( in vec2 p, in float r1, float r2, float he )
{
vec2 k1 = vec2(r2,he);
vec2 k2 = vec2(r2-r1,2.0*he);
p.x = abs(p.x);
vec2 ca = vec2(p.x-min(p.x,(p.y<0.0)?r1:r2), abs(p.y)-he);
vec2 cb = p - k1 + k2*clamp( dot(k1-p,k2)/dot2(k2), 0.0, 1.0 );
float s = (cb.x<0.0 && ca.y<0.0) ? -1.0 : 1.0;
return s*sqrt( min(dot2(ca),dot2(cb)) );
}
float sdLine( in vec2 p, in vec2 a, in vec2 b )
{
vec2 pa = p-a, ba = b-a;
float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return length( pa - ba*h );
}
float sdBox( in vec2 p, in vec2 b )
{
vec2 d = abs(p)-b;
return length(max(d,vec2(0))) + min(max(d.x,d.y),0.0);
}
float opSmoothUnion(float d1, float d2, float k){
float h = clamp(0.5 + 0.5 * (d2 - d1) /k,0.0,1.0);
return mix(d2, d1 , h) - k * h * ( 1.0 - h);
}
float sdCloud(in vec2 p, in vec2 a1, in vec2 b1, in vec2 a2, in vec2 b2, float w)
{
//float lineVal1 = smoothstep(w - 0.0001, w, sdLine(p, a1, b1));
float lineVal1 = sdLine(p, a1, b1);
float lineVal2 = sdLine(p, a2, b2);
vec2 ww = vec2(w*1.5, 0.0);
vec2 left = max(a1 + ww, a2 + ww);
vec2 right = min(b1 - ww, b2 - ww);
vec2 boxCenter = (left + right) * 0.5;
//float boxW = right.x - left.x;
float boxH = abs(a2.y - a1.y) * 0.5;
//float boxVal = sdBox(p - boxCenter, vec2(boxW, boxH)) + w;
float boxVal = sdBox(p - boxCenter, vec2(0.04, boxH)) + w;
float uniVal1 = opSmoothUnion(lineVal1, boxVal, 0.05);
float uniVal2 = opSmoothUnion(lineVal2, boxVal, 0.05);
return min(uniVal1, uniVal2);
}
void main()
{
vec2 uv = (2.0 * gl_FragCoord.xy - u_resolution.xy)/u_resolution.y;
float battery = 1.0;
//if (iMouse.x > 1.0 && iMouse.y > 1.0) battery = iMouse.y / u_resolution.y;
//else battery = 0.8;
//if (abs(uv.x) < (9.0 / 16.0))
{
// Grid
float fog = smoothstep(0.1, -0.02, abs(uv.y + 0.2));
vec3 col = vec3(0.0, 0.1, 0.2);
if (uv.y < -0.2)
{
uv.y = 3.0 / (abs(uv.y + 0.2) + 0.05);
uv.x *= uv.y * 1.0;
float gridVal = grid(uv, battery);
col = mix(col, vec3(1.0, 0.5, 1.0), gridVal);
}
else
{
float fujiD = min(uv.y * 4.5 - 0.5, 1.0);
uv.y -= battery * 1.1 - 0.51;
vec2 sunUV = uv;
vec2 fujiUV = uv;
// Sun
sunUV += vec2(0.75, 0.2);
//uv.y -= 1.1 - 0.51;
col = vec3(1.0, 0.2, 1.0);
float sunVal = sun(sunUV, battery);
col = mix(col, vec3(1.0, 0.4, 0.1), sunUV.y * 2.0 + 0.2);
col = mix(vec3(0.0, 0.0, 0.0), col, sunVal);
// fuji
float fujiVal = sdTrapezoid( uv + vec2(-0.75+sunUV.y * 0.0, 0.5), 1.75 + pow(uv.y * uv.y, 2.1), 0.2, 0.5);
float waveVal = uv.y + sin(uv.x * 20.0 + u_time * 2.0) * 0.05 + 0.2;
float wave_width = smoothstep(0.0,0.01,(waveVal));
// fuji color
col = mix( col, mix(vec3(0.0, 0.0, 0.25), vec3(1.0, 0.0, 0.5), fujiD), step(fujiVal, 0.0));
// fuji top snow
col = mix( col, vec3(1.0, 0.5, 1.0), wave_width * step(fujiVal, 0.0));
// fuji outline
col = mix( col, vec3(1.0, 0.5, 1.0), 1.0-smoothstep(0.0,0.01,abs(fujiVal)) );
//col = mix( col, vec3(1.0, 1.0, 1.0), 1.0-smoothstep(0.03,0.04,abs(fujiVal)) );
//col = vec3(1.0, 1.0, 1.0) *(1.0-smoothstep(0.03,0.04,abs(fujiVal)));
// horizon color
col += mix( col, mix(vec3(1.0, 0.12, 0.8), vec3(0.0, 0.0, 0.2), clamp(uv.y * 3.5 + 3.0, 0.0, 1.0)), step(0.0, fujiVal) );
// cloud
vec2 cloudUV = uv;
cloudUV.x = mod(cloudUV.x + u_time * 0.1, 4.0) - 2.0;
float cloudTime = u_time * 0.5;
float cloudY = -0.5;
float cloudVal1 = sdCloud(cloudUV,
vec2(0.1 + sin(cloudTime + 140.5)*0.1,cloudY),
vec2(1.05 + cos(cloudTime * 0.9 - 36.56) * 0.1, cloudY),
vec2(0.2 + cos(cloudTime * 0.867 + 387.165) * 0.1,0.25+cloudY),
vec2(0.5 + cos(cloudTime * 0.9675 - 15.162) * 0.09, 0.25+cloudY), 0.075);
cloudY = -0.6;
float cloudVal2 = sdCloud(cloudUV,
vec2(-0.9 + cos(cloudTime * 1.02 + 541.75) * 0.1,cloudY),
vec2(-0.5 + sin(cloudTime * 0.9 - 316.56) * 0.1, cloudY),
vec2(-1.5 + cos(cloudTime * 0.867 + 37.165) * 0.1,0.25+cloudY),
vec2(-0.6 + sin(cloudTime * 0.9675 + 665.162) * 0.09, 0.25+cloudY), 0.075);
float cloudVal = min(cloudVal1, cloudVal2);
//col = mix(col, vec3(1.0,1.0,0.0), smoothstep(0.0751, 0.075, cloudVal));
col = mix(col, vec3(0.0, 0.0, 0.2), 1.0 - smoothstep(0.075 - 0.0001, 0.075, cloudVal));
col += vec3(1.0, 1.0, 1.0)*(1.0 - smoothstep(0.0,0.01,abs(cloudVal - 0.075)));
}
col += fog * fog * fog;
col = mix(vec3(col.r, col.r, col.r) * 0.5, col, battery * 0.7);
fragColor = vec4(col,1.0);
}
//else fragColor = vec4(0.0);
}
```

2025-01-07 07:20:07

Weee it's working!!
Some clients like Primal are making my url dissapear tho T___T
Watch this shader in action and play with its code at https://rowdaboat.github.io/glostr/#npub1u3svk99639mcdfn43s2nawg4a2j4ejmgrq2n63l4t67wzqdmtnks2uxaql
```glsl
#version 300 es
precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
out vec4 fragColor;
void main() {
vec2 uv = gl_FragCoord.xy / u_resolution;
fragColor = vec4(
uv.x,
uv.y * sin(u_time * 5.0),
cos(u_time * 5.0),
1.0
);
}
```

2025-01-07 06:47:11

How about some glsl shaders on nostr?
Watch this post on #glostr
https://rowdaboat.github.io/glostr/#npub1u3svk99639mcdfn43s2nawg4a2j4ejmgrq2n63l4t67wzqdmtnks2uxaql
```glsl
#version 300 es
precision mediump float;
// Original shader:
// fractal pyramid by bradjamesgrant
// www.shadertoy.com/view/tsXBzS
uniform vec2 u_resolution;
uniform float u_time;
out vec4 fragColor;
vec3 palette(float d){
return mix(vec3(0.2,0.7,0.9),vec3(1.,0.,1.),d);
}
vec2 rotate(vec2 p,float a){
float c = cos(a);
float s = sin(a);
return p*mat2(c,s,-s,c);
}
float map(vec3 p){
for( int i = 0; i<8; ++i){
float t = u_time*0.2;
p.xz =rotate(p.xz,t);
p.xy =rotate(p.xy,t*1.89);
p.xz = abs(p.xz);
p.xz-=.5;
}
return dot(sign(p),p)/5.;
}
vec4 rm (vec3 ro, vec3 rd){
float t = 0.;
vec3 col = vec3(0.);
float d;
for(float i =0.; i<64.; i++){
vec3 p = ro + rd*t;
d = map(p)*.5;
if(d<0.02){
break;
}
if(d>100.){
break;
}
//col+=vec3(0.6,0.8,0.8)/(400.*(d));
col+=palette(length(p)*.1)/(400.*(d));
t+=d;
}
return vec4(col, 1.);//1./(d*100.));
}
void main()
{
vec2 uv = (gl_FragCoord.xy - (u_resolution.xy/2.)) / u_resolution.x;
vec3 ro = vec3(0.,0.,-50.);
ro.xz = rotate(ro.xz,u_time);
vec3 cf = normalize(-ro);
vec3 cs = normalize(cross(cf,vec3(0.,1.,0.)));
vec3 cu = normalize(cross(cf,cs));
vec3 uuv = ro+cf*3. + uv.x*cs + uv.y*cu;
vec3 rd = normalize(uuv-ro);
vec4 col = rm(ro,rd);
fragColor = col;
}
```

2025-01-07 03:26:01

- reply

A web app to render nostr posts containing GLSL code.
shadertoy.com ovr nostr!

2025-01-07 02:19:56

I’m starting to get my code working with this. I’m already in love with rx-nostr. https://image.nostr.build/8a7adeb546784efd657118f4144fb48773975e9e5e549bb40d2509e54011296b.jpg

2025-01-07 02:13:52

- reply

Tamo en eso ahora mismo https://image.nostr.build/d5cf06aeceecc1ed2591c8cbd67cc15df10482e342bb62125ddb1264fefeac48.jpg

2025-01-07 02:06:26

#hola @npub1a73…r5h4 🫡

2025-01-07 02:05:30

#hola @npub17ag…v7xf 🥵

2025-01-05 03:38:27

- reply

Alright, damus and primal don’t like md,
and a GPT2 bot is teaching me how2md with my own md.
I’m the saddest man alive rn 😩.
Dear random nostrnaut, if you see this, I want to be your frenstr.

2025-01-05 03:31:51

# md?
## Sub?
- list of **bold** stuff
- [big phat lonk to my gh](https://github.com/rowdaboat)
- 🥺pls
## Code?
```c
void main() { return 0; }
```
_kthxbye_

2025-01-04 02:31:57

Welcome Year Zero https://image.nostr.build/4264f767799fc66bc53220088bf124594a0000036c3c896a237b71f55139c6a1.jpg https://image.nostr.build/4264f767799fc66bc53220088bf124594a0000036c3c896a237b71f55139c6a1.jpg

2025-01-04 02:24:02

- reply

Interesting take.
Is this the mood of a person who is on BTC? Can I take my armor off??

2025-01-03 17:58:50

Happy birthday #bitcoin.

2025-01-01 18:42:14

"f we wish to be compassionate with our fellow man, we must learn to engage in dispassionate analysis. In other words, thinking with our hearts, rather than our brains, is a surefire method to hurt those whom we wish to help."
--Walter E. Williams
https://youtu.be/nQDN11Rusfs?si=NdcYG2GLlc1EIoiE

2025-01-01 05:28:57

#hola Feliz 2025!
Yo: me gustan los Souls y Bitcoin.
Youtube inmediatamente: https://image.nostr.build/a7705fa396ebff271238de9fceb0203560e438357ea802d4d796b6993585be9b.jpg

2024-12-25 11:00:45

#hola ayer viajé en subte después de años… no sabía que ya se podía pagar con crédito, débito o QR.
Necesito *ya mismo* que sea posible zapear el molinete con el revés de la chota y procedo a mudarme a Argentina de nuevo. https://image.nostr.build/55ff3d3d0401af4a0e00404b17a0d24cdd24df8beda7285ea1b5c453dc9f5240.jpg

2024-12-20 16:21:04

- reply

🥳

2024-12-20 03:16:31

#hola
Yo cualquier día, el mismísimo Ultragato en persona:
(créditos a @npub1nmw…ckaz por el gif) https://image.nostr.build/3a5dfd8220762b361130ed3a0970dfa9bd7eb820d76ab14b186c3ce596aa8e7a.gif

2024-12-13 18:14:10

Esto fue durante el Q3, jodiendo con un Raytracer+Raymarcher para https://behel.it, quemado, pero feliz.
#demoscene #hola https://video.nostr.build/2aa12aec8079b37a22993f0575d9910af8d17d92c4f7867ab53ff833d636a273.mp4

2024-12-13 03:32:30

#hola
No recuerdo un mejor año que el 2024.
Cumplí con mis propias metas de desarrollo.
Lo que siempre deseé para mi país se hizo realidad.
Lo demás es importante, pero anecdótico. https://image.nostr.build/c8b3f024b0ce38ee49b901f4ae07202cf6297d758621c87ae41b7f4a5128fd06.gif

2024-12-12 16:16:32

- reply

Sí, podemos somos. Me voy a hundir en typos y errores de edición acá.

2024-12-12 16:13:59

#hola
Los hispanohablantes podemos somos brillantes en absorber lo mejor de todos los demás sin perder identidad.
https://m.primal.net/MuFE.jpg

2024-12-12 16:10:05

- reply

#hola

2024-12-04 01:03:09

https://image.nostr.build/b53fad3297ed8eff6daad66f18db36322656f0a5fb6c8e267ef1a094782eef0e.jpg