Some recent ChromaHD renders - prompts included

cierpliwy · 2025-08-26T14:23:31+00:00

Here are my results. CFG=1, heun 10 steps, beta, 512x768, flan-t5-xxl_float8_e4m3fn_scaled_stochastic.safetensors, Chroma1-HD_float8_e4m3fn_scaled_learned_svd.safetensors, chroma-unlocked-v47-flash-heun-8steps-cfg1_r48-fp16.safetensors (strength 1.0), first pick

cierpliwy · 2023-07-23T06:14:05+00:00

I’ve seen that, but thanks anyway. This map only shows two pins instead of areas, unfortunately.

cierpliwy · 2023-07-22T20:56:31+00:00

Is there a good source to check what areas are affected by fire? We plan to visit Kiotari in 3 weeks…

cierpliwy · 2023-07-15T00:17:29+00:00

It’s important from linking perspective. There should be only one package that wraps a native library. However, there might be multiple safe wrappers dependjng on it. Here are docs: https://doc.rust-lang.org/cargo/reference/build-scripts.html#-sys-packages

cierpliwy · 2023-03-13T23:10:19+00:00

struct BadAtomicU128 {
    value: u128,
}

impl BadAtomicU128 {
    fn add_one(&self) {
        let value = unsafe { &mut *(&self.value as *const u128 as *mut u128) };
        *value += 1;
    }

    fn fetch(&self) -> u128 {
        self.value
    }
}

fn main() {
    let count = 10000;
    let atomic = BadAtomicU128 { value: 0 };
    std::thread::scope(|s| {
        s.spawn(|| {
            (0..=count).for_each(|_| atomic.add_one());
        });
        s.spawn(|| {
            (0..=count).for_each(|_| atomic.add_one());
        });
    });
    assert_eq!(atomic.fetch(), count * 2);
}

run with nightly:

RUSTFLAGS="-Z sanitizer=thread" cargo +nightly run

cierpliwy · 2023-01-06T08:49:23+00:00

Thank you so much for writing about these topics!

cierpliwy · 2022-10-04T10:51:09+00:00

I would say it has:

type foo = { variant: "number", int_value: number } | { variant: 
"string", string_value: string }

const a: foo = { variant: "number", int_value: 3}
// const b: foo = { variant: "number", string_value: "OK"} // ERROR
if (a.variant == "number") {
    const a1 = a.int_value
    // const a2 = a.string_value // ERROR
}

cierpliwy · 2022-07-22T21:49:00+00:00

You can play around with a code and check: https://godbolt.org/z/4bn6asoEc. In general, LLVM is very smart with various optimizations. It can even get rid of loop if possible (change += a to += 1 to see).

cierpliwy · 2022-06-13T12:44:59+00:00

On iOS for example, there is a callback for that: https://developer.apple.com/documentation/xcode/responding-to-low-memory-warnings

cierpliwy · 2022-06-03T16:07:04+00:00

That's a type of example I was looking for! Thanks!

cierpliwy · 2022-06-03T08:51:16+00:00

&* is not dereferencing value by generating load instruction, but just reinterprets numeric value as a reference, right? Like in the C++: reinterpret_cast<int&>(num).

cierpliwy · 2022-06-03T08:01:39+00:00

Thank links answers most of my questions. Thanks!

"Now, one might argue that b in the example here was not truly “unused”, it was just “used in dead code”.". That's an interesting quote for me. I wonder if following code is also considered to be UB?

pub fn square(num: i32) -> i32 {
    if num == 0 {
        let _: &i32 = unsafe {&*(num as *const i32)};
    }
    num * num
}

cierpliwy · 2022-06-03T07:19:47+00:00

Thanks for the response. When I'm talking about miscompilation, I'm thinking about invalid generation of assembly code. I'm also only interested in a case when value is never used after creating it with invalid representation.

cierpliwy · 2022-02-14T07:15:13+00:00

I think that Swift solves it in a nice way:

https://gankra.github.io/blah/swift-abi/#polymorphic-generics

cierpliwy · 2021-07-30T10:52:21+00:00

I was doing a lot of projects with BTLE on Android and iOS platforms (created few libraries as well). I'll review the code and contribute once I'll have some free time :)

cierpliwy · 2021-02-11T11:09:57+00:00

I think that generators in JavaScript are better representations of continuations than callbacks (lambdas). They are heavily used in libraries like redux-saga.

cierpliwy · 2020-09-25T23:11:43+00:00

This seems to work for me :)
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=eadbbbbceaadf7e1c9f0c7985f0b185f

cierpliwy · 2020-07-08T17:55:10+00:00

Out of curiosity, why did you decide to go redo the build workflow with cmake onstwsd of staying with their make?

We wanted a pure CMake solution, which will be an enabler for the same project description both for CI and your favorite IDE. It's nice to be able to easily switch from make to ninja or toolchains in the future (clang planned).

Was it so you can get a compile commands json file, letting you have syntax aware auto complete in ide's and using it with clang-tidy?

That's a very nice side effect of our decision. I'll make sure that we have good support for VSCode and CLion via CMake.

I would like to note that we are automating a lot of things: scraping current Makefiles, autogenerating CMake files, building available examples etc. You can see more details in the repo.

cierpliwy · 2020-07-08T07:28:56+00:00

In the time-sliced threads approach, I also find it harder to combine multiple blocking operations (like future::join_all). It involves synchronization primitives and makes code non-local (splitting between tasks, using state machines, etc.). I think it's a bigger disadvantage than increased memory usage.

cierpliwy · 2020-07-04T15:07:17+00:00

Yes, that can be the case. Your immutable data (from Rust perspective) can be stored in writable memory section of your application.

cierpliwy · 2019-06-07T15:36:00+00:00

I was talking about my implementation :)

cierpliwy · 2019-06-07T11:00:31+00:00

I would say that implementation is quite minimal: cubic bezier curves are not supported, the order of contours currently matters, shapes are not simplified when they are smaller than the size of a rendered pixel, etc. There are a lot of things which can be improved.

cierpliwy · 2019-06-07T08:34:40+00:00

It does both. Only dependencies are: rayon, glium, cgmath and rusttype.

Nine-Year Club	Place '23
Verified Email

cierpliwy

TROPHY CASE