## Inspiration

On the trip to HackWestern, we were looking for ideas for the hackathon. We were looking for things in life that can be improved and also existing products which are not so convenient to use.

Jim was using Benjamin's phone and got the inspiration to make a dedicated two factor authentication device, since it takes a long time for someone to unlock their phone, go through the long list of applications, find the right app that gives them the two-factor auth code, which they have to type into the login page in a short period of time, as it expires in less than 30 seconds. The initial idea was rather primitive, but it got hugely improved and a lot more detailed than the initial one through the discussion.

## What it does

It is a dedicated device with a touch screen, that provides users with their two-factor authentication keys. It uses RFID to authenticate the user, which is very simple and fast - it takes less than 2 seconds for a user to log in, and can automatically type the authentication code into your computer when you click it.

## How We built it

The system is majorly Raspberry Pi-based. The R-Pi drives a 7 inch touch screen, which acts as the primary interface with the user.
The software for the user interface and generation of authentication keys are written in Java, using the Swing GUI framework. The clients run Linux, which is easy to debug and customize.
Some lower level components such as the RFID reader is handled by an arduino, and the information is passed to the R-Pi through serial communication.
Since we lost our Wifi dongle, we used 2 RF modules to communicate between the R-Pi and the computer. It is not an ideal solution as there could be interference and is not easily expandable.

## Challenges I ran into

We have ran into some huge problems and challenges throughout the development of the project. There are hardware challenges, as well as software ones.

For example, the 7 inch display that we are using does not have an official driver for touch, so we had to go through the data sheets, and write a C program where it gets the location of the touch, and turns that into movement of the mouse pointers.

Another challenge is the development of the user interface. We had to integrate all the components of the product into one single program, including the detection of RFID (especially hard since we had to use JNI for lower level access), the generation of codes, and the communication with other devices.

## Accomplishments that I'm proud of

We are proud of ourselves for being able to write programs that can interface with the hardware. Many of the hardware pieces have very complex documentation, but we managed to read them, and understand them, and write programs that can interface with them reliably. As well, the software has many different parts, with some in C and some in Java. We were able to make everything synergize well, and work as a whole.

## What We learned

To make this project, we needed to use a multitude of skills, ranging from HOTP and TOTP, to using JNI to gain control over lower levels of the system.
But most importantly, we learnt the practical skills of software and hardware development, and have gained valuable experience on the development of projects.

## What's next for AuthFID
# Unreal EngJam

Design engineers are the latest trend in the tech space, but nobody is talking about engineer designers. We're here to change that.

Unreal EngJam (working title) is a concerningly robust, from-scratch programming language and game engine, designed from the ground up to be programmed in a Figma FigJam whiteboard.

With our incredibly high quality and extremely spaghetti programming language, you can program such things as classic single-player pong...

![pong](https://doggo.ninja/UVqBOT.png)

... and even render 3D models inside Figma:

![](https://doggo.ninja/oKQhg6.png)

## Think of All the Benefits

* Why be limited to syntax highlighting when you can color-code your software?
* Whiteboard out math and algorithms in the same space as your business logic
* The visual programming appeal of Scratch, with the power and robustness of a real programming language
* Comments are first-class, graphical, and move around as you refactor (and refactoring is as easy as drag-and-drop)

## Clippy

Make a mistake? Your favorite office assistant will hover above the relevant code and help you out:

![](https://doggo.ninja/erw3KX.png)

![](https://doggo.ninja/fQMIww.png)

## How We Built It

We wrote the programming language entirely from scratch (no dependencies) in TypeScript. We use Figma's plugin API to traverse the document and generate an AST which we can then interpret. We provide the programmer with access to render to and manipulate a "game window" inside Figma.

It is important to sufficiently emphasize that this is a full, statically-typed, dynamically-bound novel programming language designed explicitly for the medium of Figma flowcharts. For example, to define a variable you draw a box. To store values, you can draw an arrow to the box, and to read values you draw an arrow from the box. With arrows, nothing needs to be referenced by name and refactoring is easy.

The assignment of function and infix operator arguments are inferred first by applied name and then internal type.

## Challenges We Ran Into

Figma runs plugins in WASM which means it is extremely difficult to debug code, and simple bugs like stack overflows often result in cryptic low-level memory leak errors.

Also, 3D models are hard to get right :)

![broken](https://doggo.ninja/JNqtBT.png)
## Inspiration

We're avid hackers, and every hack we've done thus far has involved hardware. The hardest part is always setting up communication between the various hardware components it's -- like reinventing the internet protocol everytime you make an IoT device. Except the internet protocol is beautiful, and your code is jank. So we decided we'd settle that problem once and for all, both for out future hacks and for hackers in general.

## What it does

Now, all the code needed for an IoT device is python. You write some python code for your computer, some for the microcontroller, and we seamlessly integrate between them. And we help predict how much better your code base is as a result.

## How we built it

Microcontrollers, because they are bare-metal, don't actually run python. So we wrote a python transpiler that automatically converts python code into bare-metal-compliant C code. Then we seamlessly, securely, and efficiently transfer data between the various hardware components using our own channels protocol. The end result is that you only ever need to look at python. Based on that and certain assumptions of usage, we model how much we are able to improve your coding experience.

## Challenges we ran into

We attempted to implement a full lexical analyzer in its complex, abstract glory. That was a mistake.

## Accomplishments that we're proud of

Because the set of languages described by regex is basically equivalent to the set of all decidable problems in computer science, we used regex in place of the lexical analyzer, which was pretty interesting.
More generally, however, this was a big project with many moving parts, and a large code base. The fact that our team was able to put everything together, get things done, and come up with creative solutions on the fly was fantastic.

## What we learned

Organization with tools like trello is important.
Compilers are complex.
Merging disparate pieces of interlocking code is a difficult but rewarding process.
And many miscellaneous python tips and tricks.

## What's next for Kharon

We intend to keep updating the project to make it more robust, general, and power. Potential routes for this include more depth in the theory of the field, integrating more AI, or just commenting our code more thoroughly so others can understand it.
This project will be useful to us and other hardware hackers in the future! -- that's why we'll keep working on this :)