Nord-AI

I am a technical artist and programmer.

[Nord-AI @zerdovzad]

I built a local AI editing assistant that analyzes your music and raw footage, finds useful scenes, detects beats/drops/bass/vocal moments, and turns the analysis into an editable Premiere Pro timeline instead of making you sort everything manually.

What problem does it solve?

I make music-driven edits/AMVs myself, and one of the parts I hated most was spending hours scrubbing through footage, finding usable scenes, analyzing the track, placing markers, and building the first rough structure before I could even start doing the creative edit.

So I started building Beat Marker Pro for my own workflow.

The current workflow is roughly:

Music + raw footage
→ local music analysis
→ local AI footage/scene analysis
→ scene scoring and matching
→ beat / bass / drop / vocal markers
→ rough edit structure
→ export into Premiere Pro
→ I finish the actual creative edit manually
The important part for me was not making an AI that takes creative control away from the editor.
I wanted it to handle the repetitive part of the process and leave me with an editable timeline that I can still completely change.
Everything is processed locally on the user's PC.
No cloud footage upload.
No AI credits.
No per-generation fees.
If you already own a capable GPU, I want the software to actually use it.
There are also controls for which marker groups you want exported, so you don't have to dump thousands of detected events into Premiere. For example, you can work only with drops + kicks + vocals, or use a much more detailed analysis.
I've already been using the program in my own real editing workflow rather than only testing it on demo footage.

I'm now opening a small Founder Beta because I want feedback from actual Premiere editors on the parts that matter most: scene selection quality, marker usefulness, workflow friction, installation, and how much time it actually saves you.

Price:
$20 one-time Founder Beta access. No subscription and no AI credit system.

Demo:
https://t.co/UEzUBfZxoN

Early Access:
https://t.co/5vCnJLvNAA
I'm the developer, so feel free to be critical. If something about the workflow looks useless, overcomplicated, or like it wouldn't save you time in a real Premiere project, I'd genuinely rather hear that now than build in a vacuum.

[Nord-AI @zerdovzad]

@MrrrOzi Yeah, bro, I just decided to share my program with people because I was using it all the time myself.

[Nord-AI @zerdovzad]

Hey everyone! I’m a solo developer and video editor working on Beat Studio, a desktop tool for turning music and footage into a synced edit.

The idea came from my own AMV/GMV workflow: finding beats, marking important moments, choosing clips, and moving everything into the editor takes a lot of repetitive work. I wanted a tool that helps with that process while keeping creative decisions in the editor’s hands.

The video shows the current build and workflow.

What’s in the beta:

Music analysis with markers for beats, bass, onsets, and other detected events.

A shared workspace for audio, footage, timeline previews, and exports.

Marker and timeline exports for workflows involving Premiere Pro and DaVinci Resolve.

Optional local AI tools for audio and scene analysis through Model Hub.

A portable Windows build that opens in its own desktop window.

The base application runs locally. Optional AI features require separate model downloads, and their performance depends on your hardware.

I’m opening paid access to the early beta.

To be clear: this is still a work in progress. Bugs and rough edges are expected, and I’m looking for editors who want to try it on real projects and share honest feedback.

If you’re interested, send me a DM for pricing and access details. Tell me which editor you use and what kind of videos you make so we can check whether the current beta fits your workflow before you buy.

I’d also appreciate feedback on the demo: which part of your music-editing workflow would you most like a tool like this to handle?

Patreon:https://t.co/ft65Y9WIl4

[AJ @ItsmeAjayKV]

Repost if you think Qwen should continue to release small models.

Even if it might not be useful for you, small vram users desperately need it.

We need 35B atleast.

Qwen-4.0-35B with n-gram will be a game changer.

It will break every record, @QwenDevs give us good news please.

[Nord-AI @zerdovzad]

my new RP chat program on the local pc

[Nord-AI @zerdovzad]

Hi everyone,

I’ve been experimenting with alternative language-model architectures for a while, and I recently finished the first complete pretraining run of a new architecture I’m calling WarpState.

This is still an experimental proof of concept, not a claim that it beats Transformers or existing state-space models.

The model has 150.13M parameters and was trained from scratch on roughly 300 million English tokens from Ultra-FineWeb L2.

The full run completed successfully:

Parameters: 150.13M
Training tokens: ~300.02M
Optimizer steps: 9,156
Sequence length: 1,024
Vocabulary: 32,768
Peak VRAM: ~4.52 GB

Final sampled validation:
Loss: 3.4309
Perplexity: 30.90

Training was done locally on a laptop GPU.
I’m attaching screenshots of the training logs and some generations from the final checkpoints.
What is WarpState?
WarpState is not a standard Transformer stack.
The basic idea is to combine three things:

1. Local tiled attention
Instead of global self-attention across the entire sequence, tokens are divided into fixed 128-token chunks.
Inside each chunk, the model uses normal causal scaled-dot-product attention.

All chunks can be processed as a large batched GPU workload during training, rather than running attention token by token.

So the local path is roughly:

tokens
↓
128-token chunks
↓
causal local attention
↓
local representation

2. Fast + slow tensor memory

Completed chunks are compressed into a persistent tensor memory.

For every attention head, WarpState maintains two matrices:

Fast State
Slow State

The fast state is initialized with a relatively short memory timescale, while the slow state is initialized to retain information much longer.

Conceptually:

current chunk
↓
K and U
↓
bounded tensor write
↓
┌───────────────┐
│ Fast memory │
│ Slow memory │
└───────────────┘
↓
future chunks

The memory write is based on a bounded outer-product-like update:
write = tanh(K)^T × tanh(U) / chunk_size

and the states are updated approximately as:
Fast = decay_fast × Fast + (1 - decay_fast) × write

Slow = decay_slow × Slow + (1 - decay_slow) × write

The decay rates are learned independently per head.
They start around:
Fast decay ≈ 0.90
Slow decay ≈ 0.99

The model also learns how much fast versus slow memory to read.

3. Learned routing between local attention and memory

For every token, the model produces a gate deciding how much information should come from:

local chunk attention
vs
long-range tensor memory

Approximately:

output =
gate × local_attention
+
(1 - gate) × memory_read

So the model can use precise local token relationships while relying on the compressed state for information from previous chunks.

Shared recurrent depth
Another unusual part of WarpState is that it does not have 16 completely separate large layers.
The current model contains only 4 physical WarpState cores, but they are reused across 16 logical depth passes:
Core 0
Core 1
Core 2
Core 3
Core 0
Core 1
Core 2
Core 3
...

Each logical depth has a small learned scale and bias, so the same physical core can behave somewhat differently depending on which depth pass it is being used for.
In simplified form:
x = x × (1 + depth_scale) + depth_bias

x → shared WarpState core

The intention is to get deeper iterative computation without duplicating every large weight matrix.
During autoregressive generation, every logical depth also receives its own independent memory cache, even when two depths share the same physical core weights.
Other details
The current version uses:
d_model: 1280
heads: 20
head_dim: 64
physical cores: 4
logical depth: 16
FFN hidden: 4480
chunk size: 128
RMSNorm
SwiGLU
RoPE inside each local chunk
tied input/output embeddings

The input projection is fused and produces:

Q
K
V
local/memory gate
memory U

from one projection.

Training results

The part I was most interested in was simply whether this architecture could survive a real pretraining run.

It did.

I trained it through the full ~300M-token run without NaNs, gradient collapse, or an obvious optimization failure.

Near the end of training, gradient norms were still sitting around roughly:

0.65 – 0.75

while the learning rate had already decayed to approximately:

3e-5

Peak allocated VRAM stayed around 4.52 GB.

The model also clearly learned language structure during training.

Very early checkpoints mostly produced English-shaped noise.
Later checkpoints started forming recognizable semantic clusters and reasonably structured paragraphs.
For example, when asked about Facebook, the final model associates it with things like:

online platform
social media
sharing content
sharing information
interaction with other people
community

It is definitely not a good chatbot yet.
There are still obvious failure modes:
repetition loops
semantic attractors
weak factual recall
occasional role confusion
long-generation degeneration

The model is also only base-pretrained.

There has been no instruction tuning, SFT or RLHF, so the chat screenshots I attached should be treated as qualitative probes rather than a chatbot benchmark.

Another important limitation is the training budget.

A 150M-parameter model trained on only 300M tokens has seen roughly:

~2 training tokens per parameter

so I consider this run primarily a proof that the architecture can train, rather than a fully trained 150M language model.
What surprised me most
The interesting part for me is that the architecture appears capable of learning meaningful language representations despite:
having only four large physical cores,
repeatedly reusing those cores,
restricting attention to local 128-token windows,
and moving information between chunks through fixed-size tensor states.
The long-range memory size therefore does not grow linearly with context in the same way as a conventional full KV cache.
There is still a lot I want to test before making any strong claims.

My next steps are probably:

deterministic evaluation over the entire validation set;

a parameter-matched Transformer baseline on exactly the same data;

analysis of the fast/slow memory states;

measuring long-context behavior;

investigating the repetition/attractor problem;

eventually testing a larger training budget.

For now I mainly wanted to share the first complete run because this was the point where the architecture stopped being only an idea and became an actually trained language model.

Feedback on the architecture is welcome, especially criticism of the memory update or shared-core design.

[Nord-AI @zerdovzad]

AURORA-X — conceptual reusable methalox orbital launch vehicle. Preliminary mass model, equations and engineering feedback wanted

Hi everyone.

I’m working on a conceptual civilian orbital launch vehicle called AURORA-X, intended primarily for satellite deployment, Earth-observation missions, scientific payloads and commercial rideshare missions.

The current concept is a two-stage methalox orbital launch vehicle, using a reusable first-stage booster and a high-efficiency orbital upper stage.

This is currently a preliminary conceptual design study, not a manufacturing or flight-ready design. The numbers below are first-pass engineering assumptions that I want to test, simulate and refine.

Basic architecture

Configuration: Two-stage orbital launch vehicle
Primary mission: LEO satellite deployment
Secondary missions: SSO and higher-energy transfer missions
Propellant family: LOX / CH₄
First stage: Reusable booster
Upper stage: Orbital stage optimized for vacuum operation
Payload system: Modular payload adapter + separable fairing
Recovery concept: Controlled first-stage return and vertical recovery
The design philosophy is to find a compromise between:
payload fraction;
structural mass fraction;
staging efficiency;
reusable hardware;
launch cadence;
operational simplicity;

and cost per kilogram to orbit.

Current preliminary vehicle assumptions
These are NOT final specifications. They are placeholders for the first simulation model.
ParameterPreliminary valueOverall height~72 mMaximum diameter~4.0 mGross lift-off mass~450,000 kgNumber of stages2PropellantLOX / methaneFirst stageReusableUpper stageOrbital / high-efficiencyPreliminary LEO payload target~15–20 t classPreliminary SSO payload target~10–17 t classHigher-energy payloadmission dependent
Again, I do not consider these performance values validated yet.
One of the goals of the project is to determine whether these numbers are physically consistent with the mass fractions and Δv requirements rather than simply choosing them first and designing around them.
Preliminary mass model
At the most basic level:

m₀ = mpropellant + mdry + mpayload

For each stage I want to track:

propellant mass;
dry structural mass;
engines;
tanks;
avionics;
interstage hardware;
recovery hardware;
residual propellant;
payload carried by that stage.
A useful structural coefficient is:
ε = mdry / (mdry + mpropellant)
The intention is to optimize ε rather than assume an unrealistically light structure.
The overall payload fraction is:
PF = mpayload / mliftoff
For example, if:
mliftoff = 450 t
and
mpayload = 15 t
then:
PF ≈ 3.33%
For a 20 t payload:
PF ≈ 4.44%
Whether those values are achievable with the proposed reusable architecture is one of the things I want the simulation to determine.
Rocket equation / Δv model
The basic model starts with the Tsiolkovsky rocket equation:

Δv = Isp × g₀ × ln(m₀ / mf)

where:

Δv = available velocity change;

Isp = specific impulse;

g₀ = 9.80665 m/s²;

m₀ = initial mass;

mf = final mass after propellant consumption.

For a two-stage vehicle:
Δvtotal = Δv₁ + Δv₂
or:
Δvtotal = Isp₁ g₀ ln(m₀₁/mf₁) + Isp₂ g₀ ln(m₀₂/mf₂)
The usable orbital performance must then account for losses:
Δvorbit ≈ Δvvehicle − Δvgravity − Δvdrag − Δvsteering
So my intention is not to assume that reaching ~7.8 km/s orbital velocity means the vehicle only needs ~7.8 km/s of ideal Δv.
Orbital model
For a circular orbit:

v = √(μ / r)

where:

μ = Earth's gravitational parameter;

r = Earth radius + orbital altitude.

The specific orbital mechanical energy is:

εorbit = v²/2 − μ/r

For a circular orbit:

εorbit = −μ / (2r)

This is useful because the rocket is not simply trying to reach altitude.

The main energy requirement is achieving sufficient horizontal orbital velocity.

Thrust model

For an idealized rocket engine:

F = ṁve + (pe − pa)Ae

where:

F = thrust;

ṁ = propellant mass flow;

ve = exhaust velocity;

pe = nozzle exit pressure;

pa = ambient pressure;

Ae = nozzle exit area.
This is one of the reasons I’m treating the booster propulsion and upper-stage propulsion as separate optimization problems.
The first stage needs high thrust in atmosphere.
The upper stage benefits much more from vacuum efficiency.
Thrust-to-weight ratio

At any point:

TWR = T / (mg)

For launch:

TWR > 1

but I don’t want to maximize TWR blindly.

Too high a value increases:

structural loads;

acceleration;

engine mass;

potentially unnecessary propulsion requirements.

As propellant is consumed:

m(t) decreases

so even approximately constant thrust causes:
T/m(t) to increase

throughout the burn.

Simplified vehicle acceleration

For a simplified ascent model:

a ≈ (T − D)/m − g

where aerodynamic drag is:

D = ½ρv²CdA

with:

ρ = atmospheric density;

v = vehicle velocity;

Cd = drag coefficient;

A = reference/frontal area.

This also means vehicle diameter is not something I want to select only from packaging requirements.
Increasing diameter increases frontal area roughly as:
A = πr²
while making the vehicle extremely narrow creates its own structural and bending problems.
Dynamic pressure / Max-Q
Dynamic pressure is:

q = ½ρv²

At launch:

v ≈ 0

so q is small.

At high altitude:

ρ approaches 0

so q becomes small again.

Between those regions there is a maximum dynamic-pressure condition:

qmax = Max-Q

A major goal of the trajectory model will be keeping:

q ≤ qlimit

while also avoiding excessive gravity losses.
Gravity and drag losses
A simplified gravity-loss expression is:
Δvg ≈ ∫ g sin(γ) dt

while drag losses can be approximated by:

ΔvD ≈ ∫ (D/m) dt

This creates an interesting optimization problem:

Flying too slowly wastes Δv fighting gravity.

Flying too aggressively in dense atmosphere increases drag and dynamic pressure.

So the ascent trajectory is essentially trying to minimize:

Δvloss = Δvgravity + Δvdrag + Δvsteering

subject to aerodynamic and structural constraints.

Structural loads

A simplified aerodynamic force is:

Faero ≈ qCdA

and a first-order bending moment can be thought of as:

M ≈ Faero × L
where L represents an effective moment arm.
This is one reason I don’t think simply maximizing fineness ratio automatically produces the best launcher.
Vehicle length, diameter, stiffness and mass distribution need to be optimized together.

Center of mass

The instantaneous center of mass is:

rCM = Σ(mi ri) / Σmi

and obviously changes significantly during flight as propellant is depleted.

The model therefore needs a time-dependent:

rCM(t)

rather than a fixed center of gravity.

Rotational dynamics

A simplified moment of inertia for a cylindrical body is:

I ≈ (1/12)m(3r² + L²)

with angular acceleration:

α = τ/I

I eventually want attitude-control requirements to be coupled to changing vehicle mass and inertia rather than modeled independently.

First-stage concept

The booster is intended to do most of the early atmospheric work.

Conceptually it contains:

oxidizer tank;

methane tank;

propulsion section;

flight computers;

stage separation hardware;

aerodynamic recovery surfaces;

landing/recovery hardware.

The biggest trade is obviously reusability.

A reusable booster must carry additional:

structural reinforcement;

thermal protection where required;

recovery hardware;

landing hardware;

residual propellant.

That reduces payload performance.

So:

Payloadreusable < Payloadexpendable

is expected.

The real question is whether:

Cost/kg reusable < Cost/kg expendable

once refurbishment, operations and flight count are included.

Upper-stage concept

The upper stage has a very different optimization target.

For the booster I care heavily about thrust-to-weight ratio.

For the upper stage I care much more about:

vacuum specific impulse;

dry mass;

propellant fraction;

restart capability if needed by the mission;

payload integration;

orbital insertion accuracy.

Conceptually:

Payload
↓
Payload adapter
↓
Avionics
↓
LOX tank
↓
Methane tank
↓
Vacuum propulsion

I’m currently leaning toward a relatively simple upper stage rather than maximizing engine count or adding unnecessary complexity.

Fairing

The payload fairing exists primarily to protect the payload during atmospheric ascent from:

aerodynamic loading;

acoustic loading;

heating;

contamination/environmental exposure.

Once atmospheric density becomes sufficiently low, it becomes unnecessary carried mass and should be separated.

The exact fairing geometry and jettison conditions are still open design variables.

Reusability model

Recovery means some propellant can no longer be assigned to payload acceleration.
I therefore want to explicitly include:
mreserve > 0
for the booster.
The reusable-performance calculation needs to include the energy required for recovery rather than treating stage separation as the end of the booster mission.
The economic model can then compare that loss against hardware reuse.
Preliminary economic model

For a commercial launch system, payload alone is not the entire objective.

A basic metric is:

Ckg = Cmission / mpayload
where:
Cmission = Cpropellant + Coperations + Crefurbishment + Cvehicle/Nflights + other mission costs
If reusable hardware survives many missions:
Nflights increases

and:

Cvehicle / Nflights

can potentially become much smaller.

But this only works if inspection and refurbishment costs remain controlled.

So I want to model reusability economically rather than assuming that reusability is automatically cheaper.

Optimization problem

Eventually I would like to make AURORA-X a multidisciplinary optimization problem.

Candidate variables include:

stage mass ratio;

booster propellant fraction;

upper-stage propellant fraction;

structural coefficient;

overall diameter;
vehicle length;
payload mass;
thrust-to-weight ratio;
assumed specific impulse;
staging conditions;

recovery reserve;

fairing mass;
reusable vs expendable configurations.
A simplified objective could be:
maximize:
mpayload / mliftoff
while minimizing:
Cmission / mpayload
subject to constraints such as:
q ≤ qlimit
a ≤ alimit
σ ≤ σallowable

Δv ≥ Δvrequired

and recovery constraints for the booster.

Pareto optimization

I don’t expect there to be one universally “best” AURORA-X configuration.

Instead, I want to generate a Pareto frontier between:
maximum payload;
lowest launch mass;
lowest cost/kg;

maximum reusability;

lowest structural loading;

lowest operational complexity.

One configuration might maximize payload.

Another might sacrifice several tonnes of payload for much easier booster recovery.

Another might minimize recurring cost.

That trade space is actually one of the parts of the project that interests me most.

Simulation plan

My current idea is to build the project in several layers:

1. Mass model

Propellant, dry mass, payload, residuals and recovery hardware.

2. Atmospheric model

Density and pressure versus altitude.

3. Aerodynamic model

Cd, reference area, drag and dynamic pressure.

4. Propulsion abstraction

Thrust, Isp and mass flow without initially attempting a detailed engine design.

5. Ascent dynamics

Position, velocity, mass and flight-path evolution.

6. Staging

Mass discontinuity and second-stage initialization.

7. Orbital model

Final energy, velocity and achieved orbit.

8. Booster recovery model

Performance penalty associated with recovery.

9. Economic model

Cost per flight and cost per kilogram.

10. Optimization

Run thousands of candidate configurations and find feasible Pareto-optimal designs.
Eventually I’d like the code and model to be open so other people can reproduce the results rather than relying on a claimed payload number.
What I’d especially like feedback on
I’d appreciate criticism from people with actual rocketry/aerospace experience.
In particular:
Does the overall two-stage reusable methalox architecture make sense for this vehicle class?
Does the ~450 t / ~15–20 t LEO starting assumption look remotely plausible, or is the payload target too optimistic once recovery reserves and realistic dry mass are included?
What dry-mass/structural assumptions would be reasonable for a first conceptual model?
What important mass terms am I currently missing?
For an initial ascent simulation, would you recommend starting with a 2D/3DOF point-mass model before moving toward 6DOF?
What aerodynamic model would be appropriate before having CFD data?
Which losses should absolutely not be ignored in an early Δv budget?
What would you change about the basic architecture before spending time building the full optimizer?

What existing open-source aerospace simulation tools would you recommend for validating my own model?

Which parts of this concept currently look unrealistic or overcomplicated?

I’m not presenting AURORA-X as a finished launcher or claiming these performance figures are already achievable.

The goal is to turn it into an open conceptual aerospace engineering study, progressively replace assumptions with simulation results, publish the methodology, and revise the vehicle based on technical criticism.

I’m attaching the current AURORA-X conceptual blueprint.

Any serious engineering criticism is welcome — especially if something in the current assumptions is wrong.

Thanks!

[Nord-AI @zerdovzad]

@cyberleeeknet @RockstarGames People, no one noticed that this guy is from Russia, if anything happens to him, he will absolutely love the USA.

[Nord-AI @zerdovzad]

Hi everyone! I’m a solo developer interested in AI models. I’ve been working on SSN models for a while, and I recently came up with my own architecture called RHEA. It operates based on event reactions and doesn't use the standard layers found in Transformers. I also employ specific optimization techniques, enabling a 1-billion-parameter model to be trained on an 8GB RTX 5070 laptop, just like the one in the photo.

[Nord-AI @zerdovzad]

@EldoDebug Bro, why did you abandon your project? It was quite interesting.

[Nous Research @NousResearch]

Introducing Bot Mode for Hermes Desktop.

Your agent profiles become a series of named Bots. Each Bot has its own role, model, memory, skills and profile picture; Bots can use any model and even communicate with each other.

Build a specialist Bot once to use it forever.

[Nord-AI @zerdovzad]

@MMD_life_visual 私自身も長年MMDを使ってきましたが、年月が経つにつれてそれに飽きてしまい、MMDに似ていて新しい技術にも対応した独自のプログラムを作り始めました。

[Nord-AI @zerdovzad]

@BerserkiKun Nice looking video, hello, how are you?

[Nord-AI @zerdovzad]

#MMD

[yohawing @yohawing]

three-mmd-loader v0.7.0に更新です。

・TSL（Three Shading Language)シェーダーに対応しました。

スクショは既存のWebGLレンダラーと、TSL/WebGL TSL/WebGPU とMMDとの比較です。

こうしてみると、実機と微妙に差異があるなぁ...。

https://t.co/Q49N1hdDBd

[Nord-AI @zerdovzad]

The new shader system for MMD will be released soon, if anyone is interested, there is a link to the Discord server at the bottom, where you can learn everything about this project.

https://t.co/ZixH66mg4S

[Nord-AI @zerdovzad]

@yohawing My project has its own custom loading system but it has some bugs and not perfect. I will gladly provide you with everything I encounter. It would also be nice to see how these 2 projects would be as one. Thank you for such tools. They make everyone's life better. Here in the pho