profile
viewpoint
If you are wondering where the data of this site comes from, please visit https://api.github.com/users/Exonorid/events. GitMemory does not store any data, but only uses NGINX to cache data for a period of time. The idea behind GitMemory is simply to give users a better reading experience.

Exonorid/botlib 0

A library for making Discord bots using the JDA wrapper

Exonorid/clashos 0

multiplayer arcade game for bare metal Raspberry Pi 3 B+

Exonorid/ctregex.zig 0

Compile time regular expressions in zig

Exonorid/DiscJ 0

A Discord API wrapper in Java

Exonorid/Game-of-Life 0

I made this I hate it I hate it I hate it I hate it I hate it I hate it I hate it I hate it I hate it I hate it I hate it I hate it I hate it

Exonorid/Hacktoberfest-Mathematics 0

Math is fun so let's make some scripts and or programs that use some of your favorite math formulas and functions.

Exonorid/highlight.js 0

Javascript syntax highlighter

Exonorid/nanorc 0

Improved Nano Syntax Highlighting Files

startedGoulartNogueira/BadUI

started time in 6 days

issue commentziglang/zig

warnings generated when zig compiles mingw-w64 from source for the first time

I'm getting it on 0.9.0 as well.

andrewrk

comment created time in 15 days

push eventExonorid/zig

Jonathan Marler

commit sha 642f5df0abbcfda47df94ba657b24a913d6903d4

Expose default std.log implementation This allows root.log implementations to capture log messages, process them, and forward them to the default implementation if desired.

view details

Jonathan Marler

commit sha cadf32d74545a31daaddcfccbf0f8e68efea66a7

Expose mechanism to convert log level to text

view details

Takeshi Yoneda

commit sha 1e20a62126e66d0306a6db01b3a2ffd6b946b9b6

WASI,libc: enable tests. Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>

view details

Andrew Kelley

commit sha 1472dc3ddb6fd7932ff530e7a2fd3f0185c7353f

stage2: update ZIR for generic functions ZIR encoding for functions is changed in preparation for generic function support. As an example: ```zig const std = @import("std"); const expect = std.testing.expect; test "example" { var x: usize = 0; x += checkSize(i32, 1); x += checkSize(bool, true); try expect(x == 5); } fn checkSize(comptime T: type, x: T) usize { _ = x; return @sizeOf(T); } ``` Previous ZIR for the `checkSize` function: ```zir [165] checkSize line(10) hash(0226f62e189fd0b1c5fca02cf4617562): %55 = block_inline({ %56 = decl_val("T") token_offset:11:35 %57 = as_node(@Ref.type_type, %56) node_offset:11:35 %69 = extended(func([comptime @Ref.type_type, %57], @Ref.usize_type, { %58 = arg("T") token_offset:11:23 %59 = as_node(@Ref.type_type, %58) node_offset:11:35 %60 = arg("x") token_offset:11:32 %61 = dbg_stmt(11, 4) ``` ZIR for the `checkSize` function after this commit: ```zir [157] checkSize line(10) hash(0226f62e189fd0b1c5fca02cf4617562): %55 = block_inline({ %56 = param_comptime("T", @Ref.type_type) token_offset:11:23 %57 = as_node(@Ref.type_type, %56) node_offset:11:35 %58 = param("x", %57) token_offset:11:32 %67 = func(@Ref.usize_type, { %59 = dbg_stmt(11, 4) ``` Noted differences: * Previously the type expression was redundantly repeated. * Previously the parameter names were redundantly stored in the ZIR extra array. * Instead of `arg` ZIR instructions as the first instructions within a function body, they are now outside the function body, in the same block as the `func` instruction. There are variants: - param - param_comptime - param_anytype - param_anytype_comptime * The param instructions additionally encode the type. * Because of the param instructions, the `func` instruction no longer encodes the list of parameter types or the comptime bits. It's implied that Sema will collect the parameters so that when a `func` instruction is encountered, they will be implicitly used to construct the function's type. This is so that we can satisfy all 3 ways of performing semantic analysis on a function: 1. runtime: Sema will insert AIR arg instructions for each parameter, and insert into the Sema inst_map ZIR param => AIR arg. 2. comptime/inline: Sema will insert into the inst_map ZIR param => callsite arguments. 3. generic: Sema will map *only the comptime* ZIR param instructions to the AIR instructions for the comptime arguments at the callsite, and then re-run Sema for the function's Decl. This will produce a new function which is the monomorphized function. Additionally: * AstGen: Update usage of deprecated `ensureCapacity` to `ensureUnusedCapacity` or `ensureTotalCapacity`. * Introduce `Type.fnInfo` for getting a bunch of data about a function type at once, and use it in `analyzeCall`. This commit starts a branch to implement generic functions in stage2. Test regressions have not been addressed yet.

view details

Andrew Kelley

commit sha 609b84611dcde382af5d9fbc2345ede468d31a6f

stage2: rework runtime, comptime, inline function calls * ZIR function instructions encode the index of the block that contains the function instruction. This allows Zig to later scan the block and find the parameter instructions, which is needed for semantically analyzing function bodies. * Runtime function calls insert AIR arg instructions and then inserts Sema inst_map entries mapping the ZIR param instructions to them. * comptime/inline function call inserts Sema inst_map entries mapping the ZIR param instructions to the AIR callsite arguments. With this commit we are back to the tests passing.

view details

Andrew Kelley

commit sha 382d201781eb57d9e950ad07ce814adc5a68b329

stage2: basic generic functions are working The general strategy is that Sema will pre-map comptime arguments into the inst_map, and then re-run the block body that contains the `param` and `func` instructions. This re-runs all the parameter type expressions except with comptime values populated. In Sema, param instructions are now handled specially: they detect whether they are comptime-elided or not. If so, they skip putting a value in the inst_map, since it is already pre-populated. If not, then they append to the `fields` field of `Sema` for use with the `func` instruction. So when the block body is re-run, a new function is generated with all the comptime arguments elided, and the new function type has only runtime parameters in it. TODO: give the generated Decls better names than "foo__anon_x". The new function is then added to the work queue to have its body analyzed and a runtime call AIR instruction to the new function is emitted. When the new function gets semantically analyzed, comptime parameters are pre-mapped to the corresponding `comptime_args` values rather than mapped to an `arg` AIR instruction. `comptime_args` is a new field that `Fn` has which is a `TypedValue` for each parameter. This field is non-null for generic function instantiations only. The values are the comptime arguments. For non-comptime parameters, a sentinel value is used. This is because we need to know the information of which parameters are comptime-known. Additionally: * AstGen: align and section expressions are evaluated in the scope that has comptime parameters in it. There are still some TODO items left; see the BRANCH_TODO file.

view details

joachimschmidt557

commit sha 0bef271e75657195145a519199ce12b97db246f4

stage2 Sema: Add error notes to unresolvable peer types

view details

joachimschmidt557

commit sha fcdc5c6b3ccca5cc4e1c2353f280068d1c427153

stage2 Sema: Resolve source locations of @TypeOf parameters

view details

joachimschmidt557

commit sha 16c11988587ad78cd47ec571e1120c052abd47ed

stage2 Sema: Resolve LazySrcLocs for bitwise and arithmetic exprs

view details

Andrew Kelley

commit sha d4468affb751668e156230c32b29c84684825b4f

stage2 generics improvements: anytype and param type exprs AstGen result locations now have a `coerced_ty` tag which is the same as `ty` except it assumes that Sema will do a coercion, so it does not redundantly add an `as` instruction into the ZIR code. This results in cleaner ZIR and about a 14% reduction of ZIR bytes. param and param_comptime ZIR instructions now have a block body for their type expressions. This allows Sema to skip evaluation of the block in the case that the parameter is comptime-provided. It also allows a new mechanism to function: when evaluating type expressions of generic functions, if it would depend on another parameter, it returns `error.GenericPoison` which bubbles up and then is caught by the param/param_comptime instruction and then handled. This allows parameters to be evaluated independently so that the type info for functions which have comptime or anytype parameters will still have types populated for parameters that do not depend on values of previous parameters (because evaluation of their param blocks will return successfully instead of `error.GenericPoison`). It also makes iteration over the block that contains function parameters slightly more efficient since it now only contains the param instructions. Finally, it fixes the case where a generic function type expression contains a function prototype. Formerly, this situation would cause shared state to clobber each other; now it is in a proper tree structure so that can't happen. This fix also required adding a field to Sema `comptime_args_fn_inst` to make sure that the `comptime_args` field passed into Sema is applied to the correct `func` instruction. Source location for `node_offset_asm_ret_ty` is fixed; it was pointing at the asm output name rather than the return type as intended. Generic function instantiation is fixed, notably with respect to parameter type expressions that depend on previous parameters, and with respect to types which must be always comptime-known. This involves passing all the comptime arguments at a callsite of a generic function, and allowing the generic function semantic analysis to coerce the values to the proper types (since it has access to the evaluated parameter type expressions) and then decide based on the type whether the parameter is runtime known or not. In the case of explicitly marked `comptime` parameters, there is a check at the semantic analysis of the `call` instruction. Semantic analysis of `call` instructions does type coercion on the arguments, which is needed both for generic functions and to make up for using `coerced_ty` result locations (mentioned above). Tasks left in this branch: * Implement the memoization table. * Add test coverage. * Improve error reporting and source locations for compile errors.

view details

Andrew Kelley

commit sha f58cbef1659742e57377d3f8c92a0b9b97af91ad

stage2: std.mem.eql works now * The `indexable_ptr_len` ZIR instruction now uses a `none_or_ref` ResultLoc. This prevents an unnecessary `ref` instruction from being emitted. * Sema: Fix `analyzeCall` using the incorrect ZIR object for the generic function callee. * LLVM backend: `genTypedValue` supports a `Slice` type encoded with the `decl_ref` `Value`.

view details

Andrew Kelley

commit sha e9e3a2994696a3131125ebc4b1f0eec7ca5306d9

stage2: implement generic function memoization Module has a new field `monomorphed_funcs` which stores the set of `*Module.Fn` objects which are generic function instantiations. The hash is based on hashes of comptime values of parameters known to be comptime based on an explicit comptime keyword or must-be-comptime type expressions that can be evaluated without performing monomorphization. This allows function calls to be semantically analyzed cheaply for generic functions which are already instantiated. The table is updated with a single `getOrPutAdapted` in the semantic analysis of `call` instructions, by pre-allocating the `Fn` object and passing it to the child `Sema`.

view details

Jakub Konka

commit sha 011a468381a0217bff7f98817c0df593cbcc85ec

Link system libc if natively linking frameworks on macOS

view details

Andrew Kelley

commit sha c03a04a58942446b48e9294df991a17a3a6f7b48

stage2: return type expressions of generic functions * ZIR encoding for function instructions have a body for the return type. This lets Sema for generic functions do the same thing it does for parameters, handling `error.GenericPoison` in the evaluation of the return type by marking the function as generic. * Sema: fix missing block around the new Decl arena finalization. This led to a memory corruption. * Added some floating point support to the LLVM backend but didn't get far enough to pass any new tests.

view details

Chris Gregory

commit sha fdd97244fda948e0033034aba8042c8fdfb5d484

Make DynamicBitSet.iterator take self as const

view details

Evan Haas

commit sha 9fd3aeb8088cd9a3b0744d5f508ca256a2bbf19f

translate-c: handle macros that cast to cv void Fixes #9507

view details

Andrew Kelley

commit sha 47f2463b5c784cb7be9593f56e6b89805dbb8f06

std.HashMap: fix getPtrAdapted. AstGen: fix fn param iteration There was a bug in stage2 regarding iteration of function parameter AST. This resulted in a false negative "unused parameter" compile error, which, when fixed, revealed a bug in the std lib HashMap implementation.

view details

Andrew Kelley

commit sha 786e238a7f1034a09bc0471b3796051abb874e14

AstGen: fix function declarations They were putting their return type expressions into the wrong ZIR block, resulting in a compiler crash.

view details

Andrew Kelley

commit sha c7dc451a2a06a0ade0bb44a48cb6e5cde6e237df

stage2: more debuggable panics For now these errors are handled via `@panic` rather than `unreachable`. These are relatively likely bugs to occur at this early stage of development, and handling them as panics lets us ship release builds of the compiler without worrying about undefined behavior. Furthermore, in stage1, `@panic` is implemented to include an error return trace, while `unreachable` is not. In this case, the error return traces are extremely helpful in debugging the compiler.

view details

Andrew Kelley

commit sha 7e9b23e6dce4d87615acd635f3731731a8601d39

Sema: respect requiresComptime of function return types When doing a function call, if the return type requires comptime, the function is analyzed as an inline/comptime call. There is an important TODO here. I will reproduce the comment from this commit: > In the case of a comptime/inline function call of a generic function, > the function return type needs to be the resolved return type based on > the function parameter type expressions being evaluated with comptime arguments > passed in. Otherwise, it ends up being .generic_poison and failing the > comptime/inline function call analysis.

view details

push time in 22 days

fork Exonorid/clashos

multiplayer arcade game for bare metal Raspberry Pi 3 B+

fork in 25 days

startedPerfare/AssetStudio

started time in a month

issue commentziglang/zig

Allow `break` and `continue` in inline loops

Sorry about the title, I wasn't paying attention

Exonorid

comment created time in 2 months

issue openedziglang/zig

Allow default value for union fields

Currently, trying to compile something like

pub fn main() void {
    const Foo = struct{a: ?u8, b: ?u8, c: ?u8, d: ?u8};

    var test_foo = Foo{.a = 5, .b = 6, .c = null, .d = 9};
    inline for(std.meta.fields(Foo)) |field_info| {
        if(@field(test_foo, field_info.name) == null) continue;
        doStuff(@field(test_foo, field_info.name));
    }
}

won't work because the continue is based on a runtime value. However, there's no reason not to allow this behavior at runtime by unwrapping it into something like

if(test_foo.a == null) goto for_b;
doStuff(test_foo.a);
for_b:
if(test_foo.b == null) goto for_c;
doStuff(test_foo.b);
//etc

Although I will admit that this example is contrived, I just wanted a simple example to illustrate my point. For more complicated control flow, it can greatly simplify code and make it more readable.

created time in 2 months

push eventExonorid/zig

Jacob G-W

commit sha 759d1d9aeffbe1c5eaf7d5675b6d1c165757cdf1

astgen: errors for shadowing in loop captures

view details

Jacob G-W

commit sha 1799455e0587644c98cdba67bd10a59a2d45b116

astgen: errors for shadowing in if captures

view details

Jakub Konka

commit sha e08f7ba8896ad64a696424cff9b9c0963a7a4a0b

zld: remove redundant codepaths

view details

Jakub Konka

commit sha 9c3ebe0216306b5e346ec52959de41d1b4d504d9

zld: clean up logic for creating mach header

view details

Jakub Konka

commit sha 3622fe08dbdcaccb04204b48257e1d5fcbe0d164

zld: abstract away string table with fewer allocs

view details

Jakub Konka

commit sha 2b3bda43e352152f0150bf2e795419cf1bcfcd90

zld: abstract Symbol creation logic

view details

Jakub Konka

commit sha ee6e25bc13b3f23b5f2fd0c8b57f0d115c239fc2

zld: add Symbol.Stab and move nlist creation logic there

view details

Jakub Konka

commit sha 980f2915fa15ab35029e8f3cab21d309811f6e30

zld: use index to symbol in reloc instead of pointer to the Symbol struct in the hope that we can overwrite the Symbol in the object's symbol table with the resolved Symbol later down the line.

view details

Jakub Konka

commit sha 989639efba0a7098819c3eb85130cb50413cbf7c

zld: coalesce symbols on creation

view details

Jakub Konka

commit sha ceb431507d827f5ac53a18d8904886708325c0e7

zld: resolve symbols in dylibs using new scheme

view details

Jakub Konka

commit sha 7c82079d2cfb2f8c299707aa4c79455a73601914

zld: allocate symbols using the new scheme

view details

Jakub Konka

commit sha 3bd9f3801771189ad1aa9d9b41786026add38075

zld: reenable entire linker in the new scheme without the stabs... They are tricky and need a bit more work.

view details

Jakub Konka

commit sha 669ac92af0626b77442415e54be3f604c5b49535

zld: fix ast errors

view details

Jakub Konka

commit sha 453c16d8acead9bc5ef19155474ba8af37d151cf

zld: draft out splitting sections into blocks

view details

Jakub Konka

commit sha 5b3c4691e628cb288e6595974781ffbadb717c28

zld: put relocs in a TextBlock

view details

Jakub Konka

commit sha 5649242025cd885a6a2f0607d96f54b1926b0a5a

zld: draft up final format of TextBlock

view details

Jakub Konka

commit sha 7b4063d55899b0e35711c848f7b19de6f928282b

zld: convert section in linked list of TextBlocks

view details

Jakub Konka

commit sha 51e334af447b126862238f0743342755d719f897

zld: refactor section into TextBlocks conversion

view details

Jakub Konka

commit sha 54888c6f4699b07eadd21b744d797006fb96a284

zld: create TextBlocks for tentative definitions and fix the links in the `TextBlock`s linked list!

view details

Jakub Konka

commit sha 15b85df3dd8a754bc26159ea2202781b748a613e

zld: parse relocs per generated TextBlock

view details

push time in 2 months

delete branch Exonorid/zig

delete branch : rename_offsetOf

delete time in 2 months

fork Exonorid/ctregex.zig

Compile time regular expressions in zig

fork in 2 months

PR opened Hejsil/zig-clap

Update for Zig master
+1 -1

0 comment

1 changed file

pr created time in 2 months

create barnchExonorid/zig-clap

branch : master-fix

created branch time in 2 months

fork Exonorid/zig-clap

Simple command line argument parsing library

fork in 2 months

CommitCommentEvent

fork Exonorid/zigimg

Zig library for reading and writing different image formats

fork in 2 months

push eventExonorid/zig

Jakub Konka

commit sha 88aec4a1ee49088685b16d744f35c902c4900a09

zld: work out size and alignment of commons

view details

Jakub Konka

commit sha 96bb81b6ef0896d0b63c54bfd5d1ac0fa267d68a

zld: moving target seg,sect mapping into Object.Section

view details

Jakub Konka

commit sha 66ff56c58f3ef71f5cc3b8392632b3ec8abec43f

zld: add Symbol.Tentative to denote common symbol

view details

Jakub Konka

commit sha 03cda80a634d82e02e641fe04fa2abda4455966a

zld: handle aliasing of tentative into regular global

view details

Jakub Konka

commit sha c2086efb412f17bb52514e931016e79c65bed442

zld: synthetise regular from tentative definition

view details

Jakub Konka

commit sha 0e08cd63e236314750f18d28f8ede98a2188c6d2

zld: fix debug info for regulars synthed from tentative

view details

Jakub Konka

commit sha 183d5f4a5312c090729823dd5ebf4500c0a5a5eb

Add standalone test for common symbols

view details

Jakub Konka

commit sha e1f1f161830282ffa80f9b885fefef62862373a3

zld: clean up

view details

Andrew Kelley

commit sha 138afd5cbfbe17829082efa3084f63de88aa1c90

zig fmt

view details

Jakub Konka

commit sha a8116dcc2727e83a4c0049ca37046e05fe9de0c5

zld: fix bug in working out commons total size

view details

Felix (xq) Queißner

commit sha 437f81aa9a963af2dce654cd0ac7ac0e19a4922a

Starts to replace special cases in std.build.FileSource.

view details

Felix (xq) Queißner

commit sha 4ed567d12e2670596ebc4bf42c710b4e3210e77e

Adds more FileSources everywhere.

view details

Felix (xq) Queißner

commit sha 8501bb04ada0a29b66ba2d87ec956a4cdff46cee

Adds a lot of missing dupes, some more snakes.

view details

Felix (xq) Queißner

commit sha 56cb0b5ca0ffc4fc2c54b9dfb0f15fb7c50dc840

Moves files to file-global struct layout.

view details

Felix (xq) Queißner

commit sha 07acb1ccc97329cdcc0df37234325af9b00420a3

Changes createExecutable parameter is_dynamic to a enum to make code more readable .

view details

Felix (xq) Queißner

commit sha 27bd0971bb725fd3166bcee9364d3af868a24b5d

Changes to .path instead of .getPathFn. Changes LibExeObjStep to also provide FileSource.

view details

Felix (xq) Queißner

commit sha 98941cf27c523cd02e5c1a5fb95418a6f220e396

Makes output path stuff more sane.

view details

Felix (xq) Queißner

commit sha 1c1ea2baa7514babb2a39031753ce3a0036c5278

Code quality improvements to GeneratedFile, and manual implementation of Builder.addObjectSource.

view details

Jakub Konka

commit sha 961d556570e19c2fca1ba5ad1aadd843f012b7ed

Merge pull request #9069 from ziglang/zld-common-syms zig ld: add common (tentative) symbols support

view details

viri

commit sha 2ce033f4159409db66866e28a3591256ea0dfadc

std.os.windows: implement <timeapi.h> (#8801)

view details

push time in 2 months

issue commentziglang/zig

Proposal: Rework UEFI API

I forgot to add this, but it might be good to change functions taking a protocol GUID and pointer as parameters to instead take the protocol type and return the protocol instead of passing the GUID and a pointer to the uninitialized protocol interface. Something like:

pub fn locateProtocol(self: *const BootServices, comptime T: type, registration: ?Registration) !T {
    var handle: ?T = null;
    return switch(self._locate_protocol(&T.guid, registration, @ptrCast(*?*c_void, &handle))) {
        .Success => handle.?, //Handle is only null if the protocol is not found
        .InvalidParameter => UefiError.InvalidParameter,
        .NotFound => UefiError.NotFound,
        else => unreachable,
    };
}
Exonorid

comment created time in 2 months

issue openedziglang/zig

Proposal: Rework UEFI API

At the moment, std.os.uefi is a very barebones wrapper around UEFI. I'm proposing to rework it in the following ways:

  • Make functions that can fail return error unions
  • Pass slices to functions instead of separate lengths and pointers
  • Make reading and writing functions return the number of bytes read or written respectively
  • Use packed struct bitfields instead of ORed integers

As an example, here is the current implementation of std.os.uefi.protocols.FileProtocol.read: https://github.com/ziglang/zig/blob/132b18e2b39feca3b90b1b13df2b4649b1661fd5/lib/std/os/uefi/protocols/file_protocol.zig#L36-L38

There are two main issues with this as I see it:

  1. The function returns an enum instead of an error union. This allows the error to be fairly easily discarded using _ =. On top of that, without looking at the UEFI specification itself, it's very unclear what errors the functions could return.
  2. When passing the output buffer to the function, it takes a pointer to the buffer length as a parameter. The actual UEFI function then reads the file into the buffer and writes the number of bytes read to said pointer. On top of passing the pointer and length separately being completely unnecessary while slices exist, having the length of the buffer passed and then changed can lead to all kinds of confusion.

Under this proposal, that function would look like this:

pub fn read(self: *const FileProtocol, buffer: []u8) !usize { 
    var buffer_size = buffer.len;
    return switch(self._read(self, buffer_size, buffer.ptr)) {
        .Success => buffer_size,
        .NoMedia => UEFIError.NoMedia,
        .DeviceError => UEFIError.DeviceError,
        .VolumeCorrupted => UEFIError.VolumeCorrupted,
        .BufferTooSmall => buffer_size, //Didn't read to the end of the file, which Reader.read doesn't consider an error
        else => unreachable,
    };
} 

This implementation, while a bit more complex, is much nicer to work with as an end user, as well as being more idiomatic.

created time in 2 months

issue commentziglang/zig

stage1 C ABI compatibility

Vulkan's debug utilities use a callback of the type fn (VkDebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT, *const VkDebugUtilsMessengerCallbackDataEXT, ?*c_void) callconv(.C) u32 which doesn't compile

andrewrk

comment created time in 3 months

PR opened Iridescence-Technologies/zglfw

Fixed errors with 0.9.0
+22 -21

0 comment

1 changed file

pr created time in 3 months

create barnchExonorid/zglfw

branch : 0.9.0

created branch time in 3 months

push eventExonorid/zglfw

Exonorid

commit sha d5c726c9b77fbaf6d3f2bf0170b49734c7e13414

Updated format strings to work with Zig master

view details

Nathan Bourgeois

commit sha 12af84f0db4bb8d3db6331f9a08b7b5a14a8f0a4

Merge pull request #6 from Exonorid/string-fmt-fix Fix format strings

view details

Nathan Bourgeois

commit sha 769f14b7a009d6fab95f10f6b37b25ba1cce7c3d

Merge pull request #5 from Exonorid/master Add Gyro support

view details

Wiktor Janecki

commit sha b0850332ae049f2b3af78a8d9a2868e34b5e0286

Delete glfw with error unions

view details

Wiktor Janecki

commit sha 99f69857bf8ef2eb13689ae65c0873337a739150

Change glfw from exe to static library

view details

Wiktor Janecki

commit sha d891f419b36cb3581b822a10d76c2ea8909293ce

Update gyro support

view details

Wiktor Janecki

commit sha ddd6145320857ea98ea85dae113ad6212e15ce37

Change repo url

view details

Wiktor Janecki

commit sha e132956c41dcd7ee72e31c52ffc9dca2534d7248

Rename glfw.zig to main.zig

view details

Wiktor Janecki

commit sha 5268be562cb9c66975a4b26012287b503bd434db

Add gyro files to .gitignore

view details

Nathan Bourgeois

commit sha 17d00c597393e661048d92c61a93e7400665d3b1

Merge pull request #7 from WiktorJanecki/master Change from exe to lib

view details

push time in 3 months