Padle

padle

Simplifying Transformer Models for Faster Training and Better Performance

MVP Game Development With Flutter and Flame

ফ্লটার এবং ফ্লেম সহ MVP গেম ডেভেলপমেন্ট

MVP-Spieleentwicklung mit Flutter und Flame

Desarrollo de juegos MVP con Flutter y Flame

Développement de jeux MVP avec Flutter et Flame

फ़्लटर और फ्लेम के साथ एमवीपी गेम डेवलपमेंट

Flutter と Flame を使用した MVP ゲーム開発

Flutter 및 Flame을 사용한 MVP 게임 개발

Desenvolvimento de jogos MVP com Flutter and Flame

Разработка игр MVP с Flutter и Flame

Flutter ve Flame ile MVP Oyun Geliştirme

Phát triển trò chơi MVP với Flutter và Flame

使用 Flutter 和 Flame 进行 MVP 游戏开发

Navigation with Large Language Models: Discussion and References

Gemini - A Family of Highly Capable Multimodal Models: Discussion and Conclusion, References

RISC-V is an open-source instruction set architecture (ISA) that has gained popularity due to its simplicity and flexibility. In this article, we’ll explore the fundamentals of RISC-V assembly language by building an assembler in C#. Our goal is to read RISC-V assembly code, identify the instruction type, and convert it into machine code. We’ll use Visual Studio as our development environment for this project. Setting Up the Project Let’s begin by creating a new project in Visual Studio. We’ll build our RISC-V assembler step by step. We mention that we will be building the assembler incrementally, and the first task is to set up a loop to read a file containing RISC-V assembly code and iterate over each line. This loop will serve as the foundation for processing the assembly code. string[] lines = File.ReadAllLines(filePath);

foreach (string line in lines)
{
  // Process the 'line' here, e.g., identify instruction type, parse, and convert to machine code
} Identifying Instruction Types RISC-V instructions are categorized into different types: R, U, I, B, S, and J. To determine the type of instruction, we’ll use a lookup table for opcodes, func2, and func7. You can find the lookup table in this . file Here’s an example of how to identify the instruction type: switch (opCode)
{
    case (OpCode)0b0110011:
        return InstructionType.R;
    case (OpCode)0b0010111:
        return InstructionType.U;
    case (OpCode)0b0110111:
        return InstructionType.U;
    case (OpCode)0b0010011:
        return InstructionType.I;
    case (OpCode)0b1100011:
        return InstructionType.B;
    case (OpCode)0b0000011:
        return InstructionType.I;
    case (OpCode)0b0100011:
        return InstructionType.S;
    case (OpCode)0b1101111:
        return InstructionType.J;
    default:
        return InstructionType.Unknown;
} You can find the implementation of this function in the file. RiscVAssembler.cs Parsing Instructions Now that we can identify the instruction type, let’s parse each instruction based on its type. We’ll start with the R-type instructions, which have the syntax: . op rd, rs1, rs2 For example, the instruction can be parsed as follows: add x10, x1, x2 Regex rTypeRegex = new Regex(@"^(\w+)\s+(\w+),\s+(\w+),\s+(\w+)$");
Match rTypeMatch = rTypeRegex.Match(instruction);
if (rTypeMatch.Success)
{
    return new RiscVInstruction
    {
        Instruction = instruction,
        Opcode = rTypeMatch.Groups[1].Value,
        Rd = rTypeMatch.Groups[2].Value,
        Rs1 = rTypeMatch.Groups[3].Value,
        Rs2 = rTypeMatch.Groups[4].Value,
        Immediate = null,
        InstructionType = InstructionType.R
    };
} You can find the complete implementation of the R-type instruction parser in the file. R_Parser.cs Converting to Machine Code Once we’ve parsed an instruction, we can convert it into machine code. Each instruction type has its own format. For R-type instructions, the format is as follows: R type: .insn r opcode6, func3, func7, rd, rs1, rs2
+-------+-----+-----+-------+----+---------+
| func7 | rs2 | rs1 | func3 | rd | opcode6 |
+-------+-----+-----+-------+----+---------+
31      25    20    15      12   7        0 For example, the instruction is translated into , where: add x10, x1, x2 00000000001000001000010100110011 Opcode 6: 0110011 Rd = 01010 Func 3 = 000 Rs1 = 00001 Rs2 = 00010 Func7 = 0000000 Here’s an example of how to convert the parsed instruction into machine code: string opcode = ((int)instruction.OpcodeBin).ToBinary(7);
string rdBinary = Convert.ToString(int.Parse(instruction.Rd.Substring(1)), 2).PadLeft(5, '0');
string func3 = ((int)instruction.Funct3).ToBinary(3);
string rs1Binary = Convert.ToString(int.Parse(instruction.Rs1.Substring(1)), 2).PadLeft(5, '0');
string rs2Binary = Convert.ToString(int.Parse(instruction.Rs2.Substring(1)), 2).PadLeft(5, '0');
string func7 = ((int)instruction.Funct7).ToBinary(7);

return new MachineCode($"{func7}{rs2Binary}{rs1Binary}{func3}{rdBinary}{opcode}", instruction.Instruction); You can find the complete implementation of machine code generation in the file. R_MachineCode.cs Conclusion In this article, we’ve embarked on a journey to learn RISC-V assembly language by building an assembler in C#. We’ve covered the basics of reading RISC-V assembly code, identifying instruction types, parsing instructions, and converting them into machine code. This project serves as a valuable learning experience for understanding the inner workings of RISC-V assembly language and its translation into machine code. To delve deeper into the RISC-V architecture, refer to the . RISC-V Specification Here’s the GitHub repository link for the project where you can find the code for building a RISC-V assembler in C#: . SharpRISCV GitHub Repository If you find the project helpful and informative, don’t forget to give it a star on GitHub to show your support. In the of our RISC-V assembly language learning series, we will explore , which are essential concepts for understanding and writing more complex assembly programs. Stay tuned for the next installment! next part addressing modes, labels, and offsets Also published . here

Understanding RISC-V Assembly Language by Building an Assembler in C#

My blogs chronicle my experience as a technologist making my way into Silicon Valley. I am a queer person of color, gender non-conforming, immigrant, and ex-foster youth. I come from a non-traditional coding background. I studied a few CS courses in college and ended up majoring in the humanities before becoming a teacher. Teaching web development to under served teens turned me on to coding. After finishing at a coding school, I began working at start ups in San Francisco. Half of my blogs are about technical subjects and the other half are about equality and tech access (my journey). During the days of Windows 95 right before the internet arrived, a lot of the apps we used lived in our desktop PCs. Applications of varied sizes ran our computers. These programs allowed us to play games, manage tasks, interact with audio/video files, and save files onto disks. Browser (UI) testing an application meant writing a program that would take screenshots while a user interacted with its features. Everything QA engineers needed to test had to go through the front end. You can imagine this was expensive (CPU costs) and time consuming. These days, most of the applications we use live on the web or as apps on our smartphones. User interaction (UI) and the front end have become extremely important. Sleek UI design can set an application apart from its competitors. As the front end of applications become more complex so has UI testing. Though in some sense, UI testing still tends to be brittle, advancement in UI testing tools have allowed engineers more capabilities to test the UI than ever before. This blog will walk you through how to write a log in test using page and . . At a high level, page objects are just objects OR classes that represent a page of an application and its functionality. It does not have to represent the ENTIRE page. It could be a section of the page, for example the navbar. object models NightwatchJS Here is an in depth overview of page object models Page Object Models allows us to be able to separate the tests for a page from its selectors, layout and functionality. NightwatchJS uses an object syntax for its page objects. Let’s write a basic test in NightwatchJS and then refactor that using the Page Object Model. Create a new directory where we will store our test folder along with our page objects. mkdir nightwatch-pageObjectcd nightwatch-pageObjectmkdir ui_tests Initialize your node package manager. cd nightwatch-pageObjectnpm init Once you see your file, install Nightwatch globally so you can have access to its commands. You will also need to install it as a dependency to be able to run our tests. package.json npm install -g nightwatchnpm install nightwatch --save-dev To automate our tests and be able to control the browser, we will need to be able to start the server. Make sure you have java, to check type Selenium java -version If you don’t, check out these docs Nightwatch has the ability to run the server automatically through its test runner. Let’s create a nightwatch.conf.js file at the top level directory. touch nightwatch.conf.js We’ll cut and paste a basic config file for now, which can be found here const seleniumServer = require("selenium-server");const chromedriver = require("chromedriver");const SCREENSHOT_PATH = "./screenshots/"; module.exports = {"src_folders": ["test/ui_tests"],"output_folder": "./reports","selenium": {"start_process": true,"server_path": seleniumServer.path,"host": "127.0.0.1","port": 4444,"cli_args": {"webdriver.chrome.driver" : chromedriver.path}},"test_settings": {"default": {"screenshots": {"enabled": true,"path": SCREENSHOT_PATH},"globals": {"waitForConditionTimeout": 5000},"desiredCapabilities": {"browserName": "chrome",}}}}; function padLeft (count) { // theregister.co.uk/2016/03/23/npm_left_pad_chaos/return count < 10 ? '0' + count : count.toString();} var FILECOUNT = 0; // "global" screenshot file count/*** The default is to save screenshots to the root of your project even though* there is a screenshots path in the config object above! ... so we need a* function that returns the correct path for storing our screenshots.* While we're at it, we are adding some meta-data to the filename, specifically* the Platform/Browser where the test was run and the test (file) name.*/function imgpath (browser) {var a = browser.options.desiredCapabilities;var meta = [a.platform];meta.push(a.browserName ? a.browserName : 'any');meta.push(a.version ? a.version : 'any');meta.push(a.name); // this is the test filename so always exists.var metadata = meta.join('~').toLowerCase().replace(/ /g, '');return SCREENSHOT_PATH + metadata + '_' + padLeft(FILECOUNT++) + '_';} module.exports.imgpath = imgpath;module.exports.SCREENSHOT_PATH = SCREENSHOT_PATH; Whew, that’s a lot of code. Don’t fret, it’s dense but readable. First, let’s install selenium-server and chromedriver npm install selenium-server chromedriver --save-dev Here’s a quick run down of the code you pasted into your file: nightwatch.conf.js Requires selenium-server and chromedriver const seleniumServer = require("selenium-server");const chromedriver = require("chromedriver"); 3. Tells Nightwatch where the test code is located "src_folders": ["test/ui_tests"], 4. Makes sure the test runner starts the selenium server "start_process": true, 5. Selects Chrome as your desired browser "desiredCapabilities": {"browserName": "chrome",} Now, let’s run the config file to download selenium-server. node nightwatch.conf.js We’re ready to write our tests. Let’s write a simple test that goes to Google’s website and checks if the page title is correct. cd ui_teststouch sauceLabs.js First, require our new Nightwatch config file: require('../../nightwatch.conf.js'); Next, let’s write our test in the same file. Nightwatch uses its own syntax which is less verbose than some test frameworks like mocha. module.exports = {"Validate Sauce Labs' Page Title": function(browser) {browser.url('https://saucelabs.com').waitForElementVisible('body').assert.title('I am a page title - Sauce Labs').saveScreenshot('saucelabs.png').end();}}; Let’s run our test that validates Sauce Lab’s page title. node_modules/.bin/nightwatch --config nightwatch.conf.js Let’s store this command into a in our file so we can simply call . script package.json npm test "scripts": {"test": "node_modules/.bin/nightwatch --config nightwatch.conf.js"} Let’s run our test again using our newly made script. npm test Woo hoo! The automated browser worked and our 2 tests passed. In the next part, we’ll rewrite this simple test using the page object model.

Writing UI Tests Using Page Object Models With NightwatchJS Part I

A key technique in image editing applications is determining the dominant colors. The identification of these dominant colors is essential for creating an image's palette, which, in turn, accurately reflects the effect of selected tools and the results of editing. This article will delve into how to determine an image's palette within a restricted color space, identify an image's dominant colors, and differentiate between a palette and dominant colors. Palette The image palette is typically a reference to all the colors present in the original image. In essence, it captures the entire range of color shades, based on the numerical scale of color stimulus signal values. If we agree on modeling a signal with a certain level of accuracy, then the range of these signal values will represent our available color palette. Each unique representation of an image and the mapping of an image's colors onto this space will be a subset of it. In digital signal processing (an image is also a signal), we often understand a variety of quantities through its discrete representation. Thus, our image palette can be viewed as a subset of all the colors in the image represented by a discrete map. Each color can be indexed and assigned a specific value in one of the color spaces. For our purposes, we'll use the RGB color model. A significant challenge in presenting the image palette in this way is the vastness of human visibility. It's unlikely we can manually analyze the entire image palette, and it often doesn't make sense to store an image represented by all the original colors. Instead, we reduce their number to a reasonable limit. This process, known as color quantization, involves lowering the number of colors from the full subset that can be represented in an image to a smaller one. For instance, 14-bit raw color data might be represented in 8-bit JPEG or 16-bit TIFF converted to 8-bit PNG. A straightforward solution to determine an image's primary colors is to envision the process of color quantization to a very limited set, such as 8 or even 3 colors. This gives us insight into the primary colors within the image, making them more noticeable and memorable. Ideally, the colors in the final image should be harmonious, following the principles outlined by or . Johannes Itten Matyushin By identifying the dominant colors of an image, we can create a tool that allows us to visualize the image's "harmony." This can also apply to the harmony of the image after filtering, or "synthetic harmonization." Below, we will make an attempt to develop such a tool. Median Cut A widely used and high-quality algorithm for compressing an image's palette is the Median Cut algorithm. It's incorporated into most major lossy image compression algorithms, such as JPEG, albeit with some modifications. The fundamental principle of the Median Cut algorithm is to sequentially divide the image's cubic histogram into medians. Each resulting subcube contains approximately an equal number of bins, or pixels of the same color. Once the division process reaches a predetermined number of subcubes, we calculate the average color of each cube and map it to the corresponding colors of the original image. This process effectively reduces the number of colors in the original image, allowing us to compress the image into a smaller file size. It might seem at first glance that the initial part of this algorithm could solve our problem of identifying the primary or dominant colors of an image. However, a potential issue arises when the number of colors into which we divide the image is too few, and we're only analyzing a small number of colors. We might end up identifying colors that don't actually exist in the image because the colors are excessively averaged. We could choose the color with the maximum bin from each cube and label it as dominant, but then it wouldn't constitute a palette anymore. So, we'll reserve this approach for determining of the image's palette, which can also be used as a tool for visually analyzing the image in terms of its "harmonious utility." To identify the dominant colors, we'll employ statistical analysis: searching for local maxima in the same cubic histogram. a compressed version Local Maxima To identify the local maxima, we will implement a specific code. The author, who is also a skilled artist, provides an excellent description of the algorithm. Essentially, we first gather the image statistics into the same three-dimensional RGB histogram used in the Median Cut algorithm. Each cell of the cubic histogram will contain color bins, and the sum of all values of each color included in the cell. Given the limited histogram dimension to a resolution of 32x32x32 (originally 30x30x30), accumulating the sum simplifies the calculation of the average cell color. We then search for the local maximum by thoroughly exploring the entire space and comparing it with neighboring cells. Following this, we iteratively reduce the number of local maxima to the required amount, discarding similar colors with less weight. For all remaining local maxima, we calculate the average colors of all values included in the list. Since the color density in local maxima is higher, and the difference between pixel values is smaller than in cubes from the Median Cut, the colors will be more akin to those present in the main image and will more accurately represent its dominant colors. This reveals the primary difference between the two models: acquiring a versus searching for local maxima or . By mapping the primary "compressed palette" image, we will create a new one , albeit in a vastly truncated form. "compressed palette" dominant colors that maintains the same color balance as the main image On the other hand, dominant colors . They cannot be transformed into anything new with a suitable color balance. only describe the composition of the colors primarily present in the image Implementation Using this task as an example, we will demonstrate how straightforward it is to develop a ready-to-use application for image analysis and manipulation using the . We will begin with functionalities that are absent in other engines. IMProcessing Framework For instance, the framework has the capacity to read Adobe files with pre-existing CLUTs and can extract a three-dimensional cubic histogram from an image in real-time. .cube Capitalizing on this, we aim to create an application that can: Upload files in JFIF (jpeg) format. “Normalize” the original image. Control the intensity of the “normalizer.” Incorporate an arbitrary LUT from an Adobe .cube file into the processing. Manage the intensity of CLUT's impact. Display a linear histogram of the image. Exhibit the “compressed palette” and dominant colors of the image as well as their numerical representation in the form of a triplet (r,g,b) The end product of our construction will resemble this interactive toy: Here, it's clear how the image's simple “normalization” positively influences the diversity of the final palette, re-distributing dominant colors into a more varied and harmonious set. "Normalizer" We will assemble a filter from two pre-existing ones: - allows the stretching of the image histogram to specified boundaries IMPContrastFilter - performs automatic white balance correction based on the search for the average color and the correction of spurious tones in the image. This is essentially a slight modification of an idea borrowed from IMPAutoWBFilter . Andrey Zhuravlev’s blog import IMProcessing
 
/// Image filter
public class IMPTestFilter:IMPFilter {
 
    /// We will use a contrast control filter through histogram stretching
    var contrastFilter:IMPContrastFilter!
 
    /// Auto white balance filter
    var awbFilter:IMPAutoWBFilter!
 
    /// Image Linear Histogram Analyzer
    var sourceAnalyzer:IMPHistogramAnalyzer!
 
    /// Solver of the histogram analyzer for calculating the lightness boundaries of the image
    let rangeSolver = IMPHistogramRangeSolver()
 
    public required init(context: IMPContext) {
        super.init(context: context)
 
        //  Initialize filters in context
        contrastFilter = IMPContrastFilter(context: context)
        awbFilter = IMPAutoWBFilter(context: context)
 
        // Add filters to the stack
        addFilter(contrastFilter)
        addFilter(awbFilter)
 
        // Initialize the histogram analyzer
        sourceAnalyzer = IMPHistogramAnalyzer(context: self.context)
 
        // Add a light boundary search solver to the analyzer
        sourceAnalyzer.addSolver(rangeSolver)
 
        // Add an observing handler to the filter for
        // to pass the current image frame to the analyzer
        addSourceObserver { (source) - Void in
            self.sourceAnalyzer.source = source
        }
 
        // Add an observing handler for updating analysis calculations to the analyzer
        sourceAnalyzer.addUpdateObserver({ (histogram) - Void in
        // set the lightness boundaries in the contrast filter each time the image changes
            self.contrastFilter.adjustment.minimum = self.rangeSolver.minimum
            self.contrastFilter.adjustment.maximum = self.rangeSolver.maximum
        })
 
    }
} Palette Solver The IMProcessing Framework stands out from many similar platforms due to its unique organization of calculations. It uses a dedicated group of filters that essentially are not processing filters. The objects of these classes do not modify the image in the homogeneous and spatial domains. Instead, they perform certain calculations and representations of metrics for analysis in special expanders to solve specific problems. For instance, an object of the IMPHistogramAnalyzer class can simultaneously add multiple solvers that calculate the average color of the image, the light range, zonal division, etc. We use the solver to extend the analysis of IMPHistogramCubeAnalyzer to calculate the palette and the list of dominant colors. The calculation results are then displayed in an updated NSTableView. import IMProcessing
 
///  Types of distribution of image color accents
///
///  - palette:   palette for quantizing image colors.
///               calculated using the median-cut transformation scheme:
///               http://www.leptonica.com/papers/mediancut.pdf
///  - dominants: calculation of dominant colors of an image by searching for local maxima
///               color distribution density functions:
///               https://github.com/pixelogik/ColorCube
///
public enum IMPPaletteType{
    case palette
    case dominants
}
 
/// Solver of the cubic color histogram analyzer IMPHistogramCubeAnalyzer
public class IMPPaletteSolver: IMPHistogramCubeSolver {
 
    /// Maximum number of palette colors for analysis
    public var maxColors = Int(8)
 
    /// List of found colors
    public var colors = [IMPColor]()
 
    /// Palette type
    public var type = IMPPaletteType.dominants
 
	  /// Solver handler handler
    /// - parameter analyzer: link to the analyzer
    /// - parameter histogram: cubic histogram of the image
    /// - parameter imageSize: image size
    public func analizerDidUpdate(analizer: IMPHistogramCubeAnalyzer, histogram: IMPHistogramCube, imageSize: CGSize) {
 
        var p = [float3]()
        if type == .palette{
            p = histogram.cube.palette(count: maxColors)
        }
        else if type == .dominants {
            p = histogram.cube.dominantColors(count: maxColors)
        }
 
        colors.removeAll()
 
        for c in p {
            colors.append(IMPColor(color: float4(rgb: c, a: 1)))
        }
    }
} We Assemble All the Components in the View Controller The controller will need the main application filter, which we'll call , a CLUT filter named IMPLutFilter, the ready-to-use IMPHistogramView for displaying a "regular" histogram, the IMPHistogramCubeAnalyzer which is a cubic histogram analyzer to which we will attach our solver, the IMPPaletteSolver. IMPTestFilter Lastly, we'll use IMPImageView as the main window for displaying the image, and the common IMPContext is the key class used by all constructors of the framework. class ViewController: NSViewController {
 
    //
    // Processing context
    //
    let context = IMPContext()
    //
    // Window for presenting the loaded image
    //
    var imageView:IMPImageView!
 
    var pannelScrollView = NSScrollView()
 
    //
    // Window for displaying the image histogram
    //
    var histogramView:IMPHistogramView!
 
    //
    // NSTableView - views of a list of colors from the palette
    //
    var paletteView:IMPPaletteListView!
 
    //
    // Main filter
    //
    var filter:IMPTestFilter!
 
    //
    // CLUT filter from Adobe Cube files
    //
    var lutFilter:IMPLutFilter?
 
    //
    // Analyzer of a cubic histogram of an image in RGB space
    //
    var histograCube:IMPHistogramCubeAnalyzer!
 
    //
    // Our solver for finding colors
    //
    var paletteSolver = IMPPaletteSolver()
 
    var paletteTypeChooser:NSSegmentedControl!
 
    override func viewDidLoad() {
 
        super.viewDidLoad()
 
        configurePannel()
 
        //
        // Initialize the objects we need
        //
 
        filter = IMPTestFilter(context: context)
 
        histograCube = IMPHistogramCubeAnalyzer(context: context)
        histograCube.addSolver(paletteSolver)
 
        imageView = IMPImageView(context: context, frame: view.bounds)
        imageView.filter = filter
        imageView.backgroundColor = IMPColor(color: IMPPrefs.colors.background)
 
        //
        // Add another handler to monitor the original image
        // (another one was added in the main filter IMPTestFilter)
        //
        filter.addSourceObserver { (source) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            //
            // to minimize calculations, the analyzer will compress the image to 1000px on the wide side
            //
            if let size = source.texture?.size {
                let scale = 1000/max(size.width,size.height)
                self.histograCube.downScaleFactor = scale.float
            }
        }
 
        // Add an observer to the filter to process the filtering results
        //
        filter.addDestinationObserver { (destination) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
 
            // pass the image to the histogram indicator
            self.histogramView.source = destination
 
            // pass the result to the cubic histogram analyzer
            self.histograCube.source = destination
        }
 
        //
        // The results of updating the analyzer calculation are displayed in the color list window
        //
        histograCube.addUpdateObserver { (histogram) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                self.paletteView.colorList = self.paletteSolver.colors
            })
        }
 
        view.addSubview(imageView)
 
....
 
        IMPDocument.sharedInstance.addDocumentObserver { (file, type) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            if type == .Image {
                do{
                    //
                    // Load the file and associate it with the filter source
                    //
                    self.imageView.source = try IMPImageProvider(context: self.imageView.context, file: file)
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        self.zoomFit()
                    })
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
            else if type == .LUT {
                do {
 
                    //
                    // Initialize the CLUT descriptor
                    //
                    var description = IMPImageProvider.LutDescription()
                    //
                    // Load CLUT
                    //
                    let lutProvider = try IMPImageProvider(context: self.context, cubeFile: file, description: &amp;amp;amp;amp;amp;amp;amp;amp;amp;description)
 
                    if let lut = self.lutFilter{
                        //
                        // If a CLUT filter has been added, update its LUT table from the file with the received descriptor
                        //
                        lut.update(lutProvider, description:description)
                    }
                    else{
                        //
                        // Create a new LUT filter
                        //
                        self.lutFilter = IMPLutFilter(context: self.context, lut: lutProvider, description: description)
                    }
 
                    //
                    // Add a LUT filter, if this filter has already been added nothing happens
                    //
                    self.filter.addFilter(self.lutFilter!)
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
        }
 
   .... As you can see, photo processing is becoming simpler and more accessible to average users, making it possible for virtually anyone to master this process. The entire project can be downloaded, assembled, and tested from the project : . For proper assembly, the mega-library for working with JPEG files (JFIF), , must be locally installed. ImageMetalling repository ImageMetalling-08 libjpeg-turbo Currently, this is the best implementation of support for this format.

How to Create an Application to Determine the Palette and Dominant Colors of an Image

একটি চিত্রের প্যালেট এবং প্রভাবশালী রঙ নির্ধারণের জন্য কীভাবে একটি অ্যাপ্লিকেশন তৈরি করবেন

So erstellen Sie eine Anwendung zum Bestimmen der Palette und der vorherrschenden Farben eines Bildes

Cómo crear una aplicación para determinar la paleta y los colores dominantes de una imagen

Comment créer une application pour déterminer la palette et les couleurs dominantes d'une image

किसी छवि के पैलेट और प्रमुख रंगों को निर्धारित करने के लिए एप्लिकेशन कैसे बनाएं

画像のパレットと主要な色を決定するアプリケーションを作成する方法

이미지의 팔레트 및 주요 색상을 결정하는 응용 프로그램을 만드는 방법

Como criar um aplicativo para determinar a paleta e as cores dominantes de uma imagem

Как создать приложение для определения палитры и доминирующих цветов изображения

Bir Görüntünün Paletini ve Baskın Renklerini Belirlemeye Yönelik Uygulama Nasıl Oluşturulur

Cách tạo một ứng dụng để xác định bảng màu và màu chủ đạo của hình ảnh

如何创建应用程序来确定图像的调色板和主色

Color serves as a fundamental element in graphic systems, particularly in interface design. Alongside form and typography, it constitutes the core of interface design. In this article, we are exploring how a cohesive structure and mathematical principles can streamline color management for designers and developers operating within a design system. To get started, we'll outline the key types of color systems necessary for scaling and enhancing flexibility within a design system. Base Palette This palette encompasses the full spectrum of utilized colors, categorizing them into various tones that range from the darkest to the lightest. At the base color palette level, you establish a system for calculating these tones, thereby contributing to the overall flexibility of the design system. Semantic Structure The semantic palette defines the framework and guidelines for working with colors within the interface. It clarifies the role of color in the interface, making the management of various tones more straightforward. This palette serves as a universal template for creating diverse themes. Theme The semantic structure serves as a template or a set of rules for shaping a theme. A theme, in turn, is a template filled with specific values of variables. It's crucial to emphasize the clear distinction between these two concepts, even though theу are inherently interconnected. A theme lacking a predefined set of rules can hinder the development of other themes and limit flexibility, particularly when it comes to custom or partner themes. Base Color Palette Colors in an interface are remarkably versatile. Although minimalist interfaces may seem to rely on just three colors - light, dark, and accent - a closer examination reveals a rich spectrum of tones. This diverse range of tones serves multiple purposes. Enhancing Interactivity This approach enables you to incorporate interactivity and empower users with control over the system. Different tones of the same color can convey the system's response to user actions, such as pointing and clicking. Managing Hierarchy and Emphasis Within any interface, elements naturally form a hierarchy. Color, combined with dimensionality, can be used to manage and highlight this hierarchy. For instance, important headlines can appear larger and darker in a light-themed design, while secondary text may be smaller and lighter to downplay its significance. Ensuring Accessibility Consider small UI elements as an example - they can benefit from being either lighter or darker to improve readability for users. Smaller elements, in particular, require increased contrast, which makes it necessary to have a variety of lightness tones. The base palette acts as the primary constraint of the variant space, enabling smooth and systematic selection of tones.  For instance, when creating a theme, you can simply utilize the adjacent shade in the palette when determining the hover color for a button (e.g., primary.bg: Marine 400, primary.bgHover: Marine 500). Creating a Base Palette Determine the Number of Tones The average number of tones for a single color in a flexible base palette is around 10 tones. For instance, Google utilizes a palette consisting of 13 tones. Use the HSL Model It is essential to utilize the HSL (hue, saturation, lightness) model alongside mathematical calculations when creating a base palette. The HSL model plays a crucial role in computing the numerical attributes of tones, ensuring alignment in terms of lightness. These calculations, in turn, eliminate the need for subjective selection of tones based on visual assessment and enable the direct calculation of tones at the front.  The HSL model facilitates the management of all three components, although in practice, it is often sufficient to calculate just one parameter, which is lightness. In my work, I also make additional adjustments to the second parameter - Hue. Lightness Lightness plays a fundamental role in generating a variety of color tones. It can be represented using numerical values ranging from 0 to 1000, with 1000 denoting black and 0 denoting white. Employing a step size of 10, you can create 9 distinct tones, excluding pure white and black from this spectrum. Numeric tone names offer a clear and straightforward way to assess any color by indicating its lightness level. For instance, names like "Blue 500" and "Gray 500" immediately signal that these colors share the same lightness parameter. Tip In practice, when creating a color palette, it is often necessary to incorporate intermediate values for both the lightest and darkest tones. Consider using intermediate tones, like 50 (with a lightness parameter of L 95) or 950 (with a lightness parameter of L -5). These tones introduce more subtle variations, thereby enriching your color scheme versatility and its visual appeal. Tip To enhance accessibility in your design, it's recommended to avoid utilizing pure black (hex code 000000) and pure white (hex code FFFFFF) in your color palette. Instead, consider utilizing tone values such as 50 and 25 for white texts when working with dark themes. This approach guarantees that texts remain easily readable and user-friendly, even in low-contrast settings. Hue Another less obvious tip is adjusting the Hue parameter when creating color tones. By doing so, you can achieve a well-balanced color palette that aligns with the way the human eye perceives colors. For instance, in lighter tones, a blue color may visually appear as purple, potentially causing perceptual distortions. By calculating color tones using the HSL model, you streamline the process of developing custom themes for partners or users. This methodology allows you to apply a single formula to create a theme for any color, thereby ensuring consistency and simplifying the theme creation process. Semantic Structure While a broad base palette of tones offers flexibility, employing it for day-to-day design tasks can be challenging. To simplify this process, it's essential to implement a semantic structure or a grouping system that maps a color token to a specific color role. This structure is critical for several reasons: Streamlined Description This approach allows you to specify only the particular set of color tokens used in the existing interface, avoiding the need  to include every color from the extensive base palette and thereby preventing design overload. Promoting Clarity within Teams Semantic structures make color names understandable to both designers and developers, promoting clarity and facilitating collaboration within large teams working on a single project. Universal Template The universal template can be easily customized to create various themes, such as light, dark, or custom themes. Within design systems, color categorization often relies on a single criterion, such as the role of tone in the hierarchy (e.g., accent, primary, secondary). To enhance future theme flexibility, consider introducing additional supplementary criteria for effective grouping. Essentially, the semantic structure should maintain consistency across different themes. This unified approach streamlines the operations with various themes, ensuring both stability and ease of use. Group by Type of Interface Elements Organizing colors based on the category of interface elements is essential for achieving a balance between simplicity and a minimal set of variables. This approach involves categorizing colors into various groups, including: Background Text and Icons Controls Dividers Links These categories collectively cover a wide range of elements commonly found in interfaces. A well-structured naming and grouping system facilitates coordination within large teams and simplifies the onboarding of new team members. When working with multiple variables, striking a balance to maintain design eloquence and consistency when developing themes can be challenging. An insufficient number of variables can impede the eloquence of the design system, while an excess of variables can jeopardize consistency. This concept can be illustrated through a focus state: by describing it within a 'Controls' group once, you eliminate the necessity to describe it separately for each type of interface components. Group Interface Elements by Type: Subgroups When grouping interface elements by type, there's often a need to introduce additional subgroups to achieve a finer level of granularity, especially when handling control states. Group Colors by Role Grouping colors according to their roles is essential for understanding the significance of each color and establishing a hierarchy within your design system. This classification includes the following major groups: Primary Colors Secondary Colors Accent Colors Neutral Colors For instance, accent colors typically serve branding purposes while secondary colors are utilized for supporting elements. Additional Labeling In addition to outlining the hierarchy of color roles,  you may also need to assign labels to define various states.  For instance, within controls,  you should specify states such as "hover," "press," and "disabled." Similarly, you might incorporate additional labels for statuses, such as "success," "error," and "warning." Such labels provide clarity and guidance when working with colors within your design system. Themes Themes have gained increasing importance in recent times, especially with the adoption of both light and dark themes as industry standards. Interface developers face additional challenges when working with custom themes, as it requires a systematic approach. On top of that, it is important to recognize that dark themes aren't merely a direct inversion of light themes. For instance, dark themes might include light-colored input fields. Such cases highlight the necessity for a more nuanced approach to themes within the design system. Summary The universal semantic structure approach offers a robust framework for organizing and managing colors within interface design systems. This method has shown to be exceptionally effective, particularly in large-scale scenarios where your interface or design system is closely affiliated with a partner brand. It can also prove valuable when managing a diverse ecosystem of various products, preventing the entry of numerous smaller design systems. After all, a visual language can be distilled down to three fundamental elements - color, typography, and shape. By utilizing variables seamlessly integrated into a unified template, you can construct a theme suitable for any visual language.

Interface Colors: From Palette to Themes

Fabric.js is a remarkable library that streamlines the usage of HTML5 canvas elements, empowering developers to effortlessly craft engaging web applications. Packed with a multitude of features and tools, it empowers users to design interactive and visually stunning interfaces. JavaScript A notable advantage of lies in its capacity to generate custom classes, enabling developers to amplify its capabilities and customize it to meet their unique requirements. Fabric.js This blog will delve into the process of designing and utilizing a personalized class in Fabric.js. Our focus will be on developing a stroked textbox with rounded corners and padding. Additionally, we will explore the adaptability of this class to cater to various scenarios. Upon completing this blog, you will possess a comprehensive grasp of crafting custom classes in Fabric.js and utilizing them to elevate your canvas applications. Creating the Stroked Textbox Class The Stroked Textbox class is an extension of the default Textbox class in Fabric.js, introducing various additional features such as stroke width, stroke color, padding, and rounded corners. Let's analyze each line of code within this class: This line specifies the object type being created. type: "textbox": This line sets the stroke width to 5 pixels. strokeWidth: 5: This line determines the stroke color as #ffb64f. strokeColor: "#ffb64f": This line indicates that the textbox should be split based on graphemes. splitByGrapheme: true: This line assigns a value of 0 to rx, controlling the degree of rounding on the x-axis. rx: 0: This line assigns a value of 0 to ry, governing the degree of rounding on the y-axis. ry: 0: This function returns an object containing all properties of the Textbox class, along with the new properties introduced by the Stroked Textbox class. toObject: _renderBackground: This function oversees the rendering process of the textbox's background, encompassing padding, rounded corners, and the stroke. _renderBackground: fabric.TextboxWithPadding = fabric.util.createClass(fabric.Textbox, {
    type: "textbox",
    strokeWidth: 5, // Specifies the width of the stroke
    strokeColor: "#ffb64f", // Sets the color of the stroke
    splitByGrapheme: true,
    rx: 0, // Determines the rx value for rounded corners on the x-axis
    ry: 0, // Determines the ry value for rounded corners on the y-axis
    toObject: function() {
        return fabric.util.object.extend(this.callSuper("toObject"), {
            backgroundColor: this.get("backgroundColor"),
            padding: this.get("padding"),
            splitByGrapheme: this.get("splitByGrapheme"),
            rx: this.get("rx"),
            ry: this.get("ry")
        });
    },

    _renderBackground: function(ctx) {
        if (!this.backgroundColor) {
            return;
        }
        var dim = this._getNonTransformedDimensions();
        ctx.fillStyle = this.backgroundColor;
        ctx.fillRect(
            -dim.x / 2 - this.padding,
            -dim.y / 2 - this.padding,
            dim.x + this.padding * 2,
            dim.y + this.padding * 2
        );
        // Stroke only at the top
        ctx.strokeStyle = this.strokeColor;
        ctx.lineWidth = this.strokeWidth;
        ctx.beginPath();
        ctx.moveTo(-dim.x / 2 - this.padding, -dim.y / 2 - this.padding);
        ctx.lineTo(-dim.x / 2 - this.padding, dim.y / 2 + this.padding);
        ctx.stroke();

        ctx.beginPath();
        ctx.strokeStyle = this.strokeColor;
        ctx.lineWidth = 0.2; // Set line width to 1
        ctx.lineTo(dim.x / 2 + this.padding, -dim.y / 2 - this.padding + 1);
        ctx.lineTo(dim.x / 2 + this.padding, dim.y / 2 + this.padding - 1);
        ctx.strokeStyle = "#9181fc";

        ctx.lineWidth = 0.2; // Set line width to 1
        ctx.lineTo(dim.x / 2 + this.padding - 1, dim.y / 2 + this.padding);
        ctx.lineTo(-dim.x / 2 - this.padding + 1, dim.y / 2 + this.padding);
        ctx.strokeStyle = "#9181fc";

        ctx.lineWidth = 0.2; // Set line width to 1
        ctx.lineTo(-dim.x / 2 - this.padding, dim.y / 2 + this.padding - 1);
        ctx.lineTo(-dim.x / 2 - this.padding, -dim.y / 2 - this.padding + 1);
        ctx.closePath();

        ctx.stroke();

        // If there is a background color, no other shadows should be casted
        this._removeShadow(ctx);
    }
}); Codebase https://github.com/dinesh-rawat-dev/Prodeasy-section-component Demo https://y5k9l8.csb.app/ Benefits of using the class With the utilization of the Stroked Textbox class, we gain the ability to generate personalized textboxes endowed with distinctive visual attributes that surpass the capabilities of the default Textbox class. This empowers us to craft canvas applications that possess enhanced visual appeal and captivate the audience with their uniqueness, setting them apart from others in the field. Using the Stroked Textbox Class To utilize the Stroked Textbox class, we can easily generate a new instance of the class and provide the necessary parameters. Below is an example demonstrating the usage of the class, showcasing the creation of a textbox with padding, rounded corners, and various stroke colors and widths: const textbox = new fabric.TextboxWithPadding('Inpur field', {
    fontFamily: "Roboto",
    // fontSize: 20,
    padding: 5,
    width: 100,
    textAlign: 'left',
    //@ts-ignore
    // left: rect.left + 20,
    //@ts-ignore
    // top: rect.top + 10,  
    selectable: true,
    evented: true,
    editable: true,
    //@ts-ignore
    placeholder: "",
    splitByGrapheme: true,
    // lockScalingX: true,
    // lockScalingY: true,
    lockMovementX: true,
    lockMovementY: true,
    fill: '#000000',
    fontSize: 10,
    // stroke: OBJECT_BORDER_COLOR,
    strokeWidth: 1,
    backgroundColor: "#d5d1eb",
    //@ts-ignore
    left: 30,
    //@ts-ignore
    top: 30,
    className: "text_box_with_padding",
    includeDefaultValues: true,
    intersectsWithFrame: true,
    hasControls: false,
    hasBorders: true,
}); In this particular instance, we have customized the textbox's appearance and behavior by configuring properties such as , , , , , , , , , , , , , and . fontFamily padding width textAlign selectable evented editable splitByGrapheme fill fontSize strokeWidth backgroundColor hasControls hasBorders Customizing the Stroked Textbox Class To further customize the Stroked Textbox class, there are two approaches you can take. Firstly, you possess the capability to modify the parameter values directly within the class itself. Alternatively, you can create a new subclass that extends the Stroked Textbox class and introduces additional functionality. Here are some suggestions on how to tailor the class to suit specific requirements: To alter the thickness of the stroke, modify the strokeWidth parameter. By adjusting the parameter, you can define the stroke thickness: increasing the value will yield a bolder stroke, while decreasing it will create a finer stroke. Adjust the stroke width: , setting strokeWidth to 10 will create a textbox with a thicker stroke compared to the default value of 5. For instance Change the stroke color: This parameter empowers you to alter the hue of the stroke, granting you greater flexibility in design choices. You can utilize a hexadecimal code or a named color. For example, setting to "#ff0000" will generate a red stroke. strokeColor To change the color of the stroke, you can adjust the value of strokeColor. This determines the space between the text and the textbox's edges. For instance, setting padding to 10 will increase the spacing around the text. Modify the padding: To change the degree of rounding on the textbox's corners, modify the values of rx and ry. These parameters govern the level of rounding on the x and y axes, respectively. For example, setting both rx and ry to 10 will create a textbox with more pronounced rounded corners. Adjust the rounding of the corners: Furthermore, you have the option to create a new subclass that extends the Stroked Textbox class and incorporates additional functionality. This approach grants you even greater customization possibilities, allowing you to introduce new features to the textbox. For instance, you could create a subclass that adds a drop shadow to the textbox or dynamically changes the font based on user input. The potential for customization is vast, and the Stroked Textbox class serves as an excellent foundation to build upon.

How to Build Custom Textboxes in Fabric.js: Stroked, Rounded, and Padded

Cómo crear cuadros de texto personalizados en Fabric.js: trazo, redondeado y acolchado

Comment créer des zones de texte personnalisées dans Fabric.js : contours, arrondis et rembourrés

फैब्रिक.जेएस में कस्टम टेक्स्टबॉक्स कैसे बनाएं: स्ट्रोक्ड, राउंडेड और पैडेड

Fabric.js でカスタム テキストボックスを構築する方法: ストローク、丸み、パディング

Como criar caixas de texto personalizadas no Fabric.js: Traçado, Arredondado e Acolchoado

Cách tạo hộp văn bản tùy chỉnh trong Fabric.js: Stroked, Rounded và Papped

如何在 Fabric.js 中构建自定义文本框：描边、圆角和填充

Write on Interaction, Reputation, or Trust, Win up to $6000 in Prizes

ইন্টারঅ্যাকশন, রেপুটেশন বা বিশ্বাসের উপর লিখুন, পুরস্কারে $6000 পর্যন্ত জিতে নিন

Schreiben Sie über Interaktion, Reputation oder Vertrauen und gewinnen Sie Preise im Wert von bis zu 6.000 US-Dollar.

Escriba sobre interacción, reputación o confianza, gane hasta $6000 en premios

Écrivez sur l'interaction, la réputation ou la confiance, gagnez jusqu'à 6 000 $ en prix

बातचीत, प्रतिष्ठा या विश्वास पर लिखें, 6000 डॉलर तक का पुरस्कार जीतें

交流、評判、信頼について書いて、最大 6,000 ドルの賞金を獲得しましょう

상호 작용, 평판 또는 신뢰에 대해 글을 쓰고 최대 $6000의 상금을 받으세요

Escreva sobre interação, reputação ou confiança e ganhe até US$ 6.000 em prêmios

Напишите о взаимодействии, репутации или доверии, выиграйте до 6000 долларов США в виде призов

Etkileşim, İtibar veya Güven Üzerine Yazın, 6000$'a Varan Ödül Kazanın

Viết về sự tương tác, danh tiếng hoặc sự tin cậy, giành được giải thưởng lên tới $6000

撰写有关互动、声誉或信任的文章，赢取高达 6000 美元的奖金

DIY Fake News Detector: Unmask misinformation with Recurrent Neural Networks

**MIAMI, Florida, July 23rd, 2024/Chainwire/--**FLOKI, the cryptocurrency ecosystem, announced today that Valhalla, a MMORPG (Massively Multiplayer Online Role-Playing Game) spin on the classic Creature-Collection adventure, will be the Associate Sponsor for India’s Tour of Sri Lanka. This partnership will give Valhalla significant visibility through mid-wicket pitch mats, ground LED boards, backdrops, and other high-visibility ground assets. Floki is the people’s cryptocurrency and the utility token of the Floki Ecosystem. FLOKI aims to become the world’s most known and used cryptocurrency, focusing on utility, philanthropy, community, and marketing. India will be touring Sri Lanka following their historic T20 World Cup championship win in the USA. The series will commence with back-to-back T20Is on July 27, followed by ODIs starting on August 1, with a two-day gap between each match. The series is expected to attract significant viewership, with estimations predicting a cumulative viewership of 180 to 220 million for both the ODI and T20I series. Sri Lanka Cricket expressed excitement about the partnership, stating it will bring more visibility and engagement to the sport. A Media Representative for FLOKI said, "It is with great enthusiasm that we at FLOKI step into a partnership to sponsor the India Tour of Sri Lanka 2024, an arena where the sport's heart beats as fervently as our dedication to being a cryptocurrency for all.” “Building on our previous associations with Cricket, FLOKI continues the belief that cricket, like FLOKI, transcends boundaries and unites people from all walks of life. Valhalla gives gamers and fans a realistic platform that they can explore alone or as a clan, partake in a dynamic, player-driven economy to rise in the community ranks, and make their mark in the competitive, animated world mirroring the opportunities cricket provides in the real world. This partnership signifies our commitment to integrating the world of gaming, cryptocurrency, and sports in a meaningful way." The series will also mark the first time both teams play under their new coaches, Gautam Gambhir for India and Sanath Jayasuriya for Sri Lanka. The Pallekele International Cricket Stadium will host the T20Is, while the R Premadasa Stadium in Colombo will host the ODIs. About Valhalla Valhalla is a spin on the classic Creature-Collection adventure set in a vibrant, lively, MMORPG open-world inspired by Norse mythology. Players interact with a diverse set of eccentric creatures called Veras, discovering, taming, training, and trading them. Alone or as a clan, players partake in a dynamic, player-driven economy to rise in community ranks and achieve tactical supremacy on the hexagonal-grid battlefield. Website: Valhalla.game About Floki Floki is the people’s cryptocurrency and utility token of the Floki Ecosystem. Floki aims to become the world’s most known and used cryptocurrency, focusing on utility, philanthropy, community, and marketing. Floki currently has over 490,000 holders and a strong brand recognized globally thanks to strategic marketing partnerships. For more information, users can visit Floki's: Website | YouTube | Telegram | Instagram | TikTok | Discord | Facebook | Reddit | Twitch Contact Community Relations Officer Pedro Vidal Floki marketing@floki.com This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. **MIAMI, Florida, July 23rd, 2024/Chainwire/--**FLOKI, the cryptocurrency ecosystem, announced today that Valhalla, a MMORPG (Massively Multiplayer Online Role-Playing Game) spin on the classic Creature-Collection adventure, will be the Associate Sponsor for India’s Tour of Sri Lanka. This partnership will give Valhalla significant visibility through mid-wicket pitch mats, ground LED boards, backdrops, and other high-visibility ground assets. Floki is the people’s cryptocurrency and the utility token of the Floki Ecosystem. FLOKI aims to become the world’s most known and used cryptocurrency, focusing on utility, philanthropy, community, and marketing. India will be touring Sri Lanka following their historic T20 World Cup championship win in the USA. The series will commence with back-to-back T20Is on July 27, followed by ODIs starting on August 1, with a two-day gap between each match. The series is expected to attract significant viewership, with estimations predicting a cumulative viewership of 180 to 220 million for both the ODI and T20I series. Sri Lanka Cricket expressed excitement about the partnership, stating it will bring more visibility and engagement to the sport. A Media Representative for FLOKI said, "It is with great enthusiasm that we at FLOKI step into a partnership to sponsor the India Tour of Sri Lanka 2024, an arena where the sport's heart beats as fervently as our dedication to being a cryptocurrency for all.” A Media Representative for FLOKI said, "It is with great enthusiasm that we at FLOKI step into a partnership to sponsor the India Tour of Sri Lanka 2024, an arena where the sport's heart beats as fervently as our dedication to being a cryptocurrency for all.” “Building on our previous associations with Cricket, FLOKI continues the belief that cricket, like FLOKI, transcends boundaries and unites people from all walks of life. Valhalla gives gamers and fans a realistic platform that they can explore alone or as a clan, partake in a dynamic, player-driven economy to rise in the community ranks, and make their mark in the competitive, animated world mirroring the opportunities cricket provides in the real world. This partnership signifies our commitment to integrating the world of gaming, cryptocurrency, and sports in a meaningful way." “Building on our previous associations with Cricket, FLOKI continues the belief that cricket, like FLOKI, transcends boundaries and unites people from all walks of life. Valhalla gives gamers and fans a realistic platform that they can explore alone or as a clan, partake in a dynamic, player-driven economy to rise in the community ranks, and make their mark in the competitive, animated world mirroring the opportunities cricket provides in the real world. This partnership signifies our commitment to integrating the world of gaming, cryptocurrency, and sports in a meaningful way." The series will also mark the first time both teams play under their new coaches, Gautam Gambhir for India and Sanath Jayasuriya for Sri Lanka. The Pallekele International Cricket Stadium will host the T20Is, while the R Premadasa Stadium in Colombo will host the ODIs. About Valhalla Valhalla is a spin on the classic Creature-Collection adventure set in a vibrant, lively, MMORPG open-world inspired by Norse mythology. Players interact with a diverse set of eccentric creatures called Veras, discovering, taming, training, and trading them. Alone or as a clan, players partake in a dynamic, player-driven economy to rise in community ranks and achieve tactical supremacy on the hexagonal-grid battlefield. Website: Valhalla.game Valhalla.game Valhalla.game About Floki Floki is the people’s cryptocurrency and utility token of the Floki Ecosystem. Floki aims to become the world’s most known and used cryptocurrency, focusing on utility, philanthropy, community, and marketing. Floki currently has over 490,000 holders and a strong brand recognized globally thanks to strategic marketing partnerships. For more information, users can visit Floki's: Floki Floki Website | YouTube | Telegram | Instagram | TikTok | Discord | Facebook | Reddit | Twitch Website Website YouTube YouTube Telegram Telegram Instagram Instagram TikTok TikTok Discord Discord Facebook Facebook Reddit Reddit Twitch Twitch Contact Community Relations Officer Pedro Vidal Floki marketing@floki.com This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here . here here

Floki’s Valhalla Joins As Associate Sponsor For India’s Tour Of Sri Lanka

ফ্লোকির ভালহাল্লা ভারতের শ্রীলঙ্কা সফরের সহযোগী স্পনসর হিসেবে যোগ দিয়েছেন

Floki’s Valhalla tritt als assoziierter Sponsor der Indien-Tour durch Sri Lanka bei

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

फ्लोकी का वल्लाह भारत के श्रीलंका दौरे के लिए सहयोगी प्रायोजक के रूप में शामिल हुआ

フロキのヴァルハラがインドのスリランカツアーのアソシエイトスポンサーに加わる

Floki의 Valhalla가 인도 스리랑카 투어의 보조 후원자로 합류

Valhalla de Floki se junta como patrocinador associado da viagem da Índia ao Sri Lanka

Valhalla Флоки станет ассоциированным спонсором индийского тура по Шри-Ланке

Floki'den Valhalla Hindistan'ın Sri Lanka Turuna Yardımcı Sponsor Olarak Katıldı

Valhalla của Floki tham gia với tư cách là nhà tài trợ liên kết cho chuyến lưu diễn Sri Lanka của Ấn Độ

Floki 的 Valhalla 成为印度环斯里兰卡赛事联合赞助商

Building a Blockchain From Scratch (kind of) with Polkadot SDK and Pop!

Creating High-Performing CTA’s: The Ultimate Guide

Is Your Reporting Software WCAG Compliant? Make Data Accessible to Everyone with Practical Steps

One of the preparatory stages of design development for any project is always the stage where the basic rules are laid down. Depending on the scale of the project, these may be some guidelines (if it is a small project involving one designer, such as a landing page), or large-scale design systems that combine several interfaces, in the work with which a group of designers participates. Regardless of the project, implementing these rules allows you to achieve consistency throughout the project, making it easier for the user to understand the interface. Also, a system of stable rules organizes all design elements and significantly speeds up the process at advanced stages; you will not have to design each individual element during scaling. It will be enough to select the necessary component and its state. Next, I will describe the basic set for a small project and the implementation process. Okay, let's start with the task. First, let's see what we have. Do we (or the design customer) have any guidelines? This could be just a logo drawn with a pen on paper. For some, it is a link to some color palette; for someone else, it is already their own corporate guideline, which already contains information about some accepted design elements. That is, there is always some starting point. If there is nothing at all, no problem, this is also a starting point. Often, even more advantageous. Let's assume that we are exactly in it. This means that we are currently limited exclusively by our imagination. Great! The main thing is not to spoil anything. To do this, you need to tune in, anything will do, the main thing is to be well inspired by something. Let's assume, however, that we already have a logo and such processes as benchmarking and elaboration of the central idea of ​​the design have been completed. Then, we boldly create our new cover and can even announce the launch of our latest project in all social networks. Choose a font if it is not regulated by the brand book. Do not underestimate this task. The font must match the brand. Plus, it is not always possible to painlessly change the font at the layout stage. In short, there are a lot of resources on the Internet for selecting a font and even a font pair. So, it is worth collecting several options and evaluating how it will look in the environment, on several screens. Then it is worth choosing a more suitable option, taking a break, and looking again the next morning. If there are no doubts, then this is a good option, if something confuses you, it is worth digging around at this stage. Having chosen the appropriate font, we form the text styles, thus, laying the foundation of the design system. There are several principles here. Everything should always be a multiple of 8 px. There is no way around it, especially if the indentation system and grid are also a multiple of 8 px. Then the logic is as follows - select several font sizes for the first screen. For this, again, we use a beautiful screen, a slogan, and see how it works. Then we determine the font sizes for the h1-h4 headings and at least two font sizes for the t1-t2 text, or better four t1-t4. We understand that the projects have the main text, various descriptions in cards, decorative elements, information about rights, etc., and with all this, we need to achieve a good level of hierarchy so that the user does not get tired when scanning the text and quickly finds important information for himself. Well, and then all the same is repeated for different styles. I have six of them in the project from L to EB. This whole process takes some time, especially at first, and I agree that there are plugins that allow you to save this time. But there are also advantages if you do everything yourself. Firstly, you will better understand the library of your styles, and it will be easier for you to choose the right style. Secondly, your library will be customized as much as possible. Working with a color palette. I already had a color palette, but to make it easier to work with the project, it is worth preparing shades for this palette in advance. In this particular project, I decided to use Radix, because this resource helps achieve an even greater level of consistency and reduces your time. Here, you can get not just a set of shades, but 12 different shades at once that are tied to individual design elements (text, buttons in different states, dividers, etc.). Plus, in one click, you can get a palette for the light and dark theme of your interface. Next, we load the resulting palette into Local variables. You can make several mods right here (light, dark, multi-colored, as many as you like). So, that in the future, by setting a certain color to different elements of the frame, you can change the color scheme of this frame in one click. This operation significantly saves time at later stages of working with the design. Also, in Local variables, it is worth immediately entering the values ​​of the rounding radii and indents. As usual, everything is a multiple of 8 px. For the radii, I make 5 values ​​from XS to XL; more is possible. Smaller values ​​are used for the smallest elements, such as buttons, and larger ones are used for graphics. This is worth doing so that, during the work process, you do not have to go back and look for the logic of decision-making at an earlier stage. With indents, the principle is the same, but there are more values, I set 13. It looks like this. When working with auto layouts, you do not need to remember the values, for example, of indents or paddings that were used earlier; they are simply pulled from the library. Let's move on to icons. For my project, I decided to use the following types of icons: special and basic. I drew the special icons, but they needed to be made more detailed. Basic icons can be found in the community. Think in advance about where these icons can be used and choose a suitable set. I planned to use them in buttons, cards, forms, etc. There is no point in overloading the library with irrelevant elements. At the moment, we have ready-made basic elements of our design guidelines: typography;
color palette;
rounding system;
indentation system;
set of icons;
so there were logos for various formats and color schemes; Plus I prepared grid styles. Now, it's time to move on to more complex components, consisting of basic ones - these are buttons, various forms, cards, header, footer, etc. But this is a topic for the next part of the tutorial. One of the preparatory stages of design development for any project is always the stage where the basic rules are laid down. Depending on the scale of the project, these may be some guidelines (if it is a small project involving one designer, such as a landing page), or large-scale design systems that combine several interfaces, in the work with which a group of designers participates. Regardless of the project, implementing these rules allows you to achieve consistency throughout the project, making it easier for the user to understand the interface. Also, a system of stable rules organizes all design elements and significantly speeds up the process at advanced stages; you will not have to design each individual element during scaling. It will be enough to select the necessary component and its state. Next, I will describe the basic set for a small project and the implementation process. Okay, let's start with the task. First, let's see what we have. Do we (or the design customer) have any guidelines? This could be just a logo drawn with a pen on paper. For some, it is a link to some color palette; for someone else, it is already their own corporate guideline, which already contains information about some accepted design elements. That is, there is always some starting point. If there is nothing at all, no problem, this is also a starting point. Often, even more advantageous. Let's assume that we are exactly in it. This means that we are currently limited exclusively by our imagination. Great! The main thing is not to spoil anything. To do this, you need to tune in, anything will do, the main thing is to be well inspired by something. Let's assume, however, that we already have a logo and such processes as benchmarking and elaboration of the central idea of ​​the design have been completed. Then, we boldly create our new cover and can even announce the launch of our latest project in all social networks. Choose a font if it is not regulated by the brand book. Do not underestimate this task. The font must match the brand. Plus, it is not always possible to painlessly change the font at the layout stage. In short, there are a lot of resources on the Internet for selecting a font and even a font pair. So, it is worth collecting several options and evaluating how it will look in the environment, on several screens. Then it is worth choosing a more suitable option, taking a break, and looking again the next morning. If there are no doubts, then this is a good option, if something confuses you, it is worth digging around at this stage. Having chosen the appropriate font, we form the text styles, thus, laying the foundation of the design system. There are several principles here. Everything should always be a multiple of 8 px. There is no way around it, especially if the indentation system and grid are also a multiple of 8 px. Then the logic is as follows - select several font sizes for the first screen. For this, again, we use a beautiful screen, a slogan, and see how it works. Then we determine the font sizes for the h1-h4 headings and at least two font sizes for the t1-t2 text, or better four t1-t4. We understand that the projects have the main text, various descriptions in cards, decorative elements, information about rights, etc., and with all this, we need to achieve a good level of hierarchy so that the user does not get tired when scanning the text and quickly finds important information for himself. Well, and then all the same is repeated for different styles. I have six of them in the project from L to EB. This whole process takes some time, especially at first, and I agree that there are plugins that allow you to save this time. But there are also advantages if you do everything yourself. Firstly, you will better understand the library of your styles, and it will be easier for you to choose the right style. Secondly, your library will be customized as much as possible. Working with a color palette. I already had a color palette, but to make it easier to work with the project, it is worth preparing shades for this palette in advance. In this particular project, I decided to use Radix, because this resource helps achieve an even greater level of consistency and reduces your time. Here, you can get not just a set of shades, but 12 different shades at once that are tied to individual design elements (text, buttons in different states, dividers, etc.). Plus, in one click, you can get a palette for the light and dark theme of your interface. Next, we load the resulting palette into Local variables. You can make several mods right here (light, dark, multi-colored, as many as you like). So, that in the future, by setting a certain color to different elements of the frame, you can change the color scheme of this frame in one click. This operation significantly saves time at later stages of working with the design. Also, in Local variables, it is worth immediately entering the values ​​of the rounding radii and indents. As usual, everything is a multiple of 8 px. For the radii, I make 5 values ​​from XS to XL; more is possible. Smaller values ​​are used for the smallest elements, such as buttons, and larger ones are used for graphics. This is worth doing so that, during the work process, you do not have to go back and look for the logic of decision-making at an earlier stage. With indents, the principle is the same, but there are more values, I set 13. It looks like this. When working with auto layouts, you do not need to remember the values, for example, of indents or paddings that were used earlier; they are simply pulled from the library. Let's move on to icons. For my project, I decided to use the following types of icons: special and basic. I drew the special icons, but they needed to be made more detailed. Basic icons can be found in the community. Think in advance about where these icons can be used and choose a suitable set. I planned to use them in buttons, cards, forms, etc. There is no point in overloading the library with irrelevant elements. At the moment, we have ready-made basic elements of our design guidelines: typography; color palette; rounding system; indentation system; set of icons; so there were logos for various formats and color schemes; typography; color palette; rounding system; indentation system; set of icons; so there were logos for various formats and color schemes; Plus I prepared grid styles. Now, it's time to move on to more complex components, consisting of basic ones - these are buttons, various forms, cards, header, footer, etc. But this is a topic for the next part of the tutorial.

The Implementation of Design Guidelines for Small and Medium Projects

Finding useful web development resources can be overwhelming for both beginners and experienced developers. With so many websites and web applications available, it can be challenging to identify the best ones. I decided to curate some of my favorite front-end resources for colors and palettes, fonts, icons, illustrations, stock photos, and videos to help web developers improve their resource stack and save time on projects. I hope these resources will help you stay informed, improve your productivity, and navigate the ever-evolving landscape of web development. Each resource will include a direct link, a description, and an image preview. 1. ThemeSelection (Sponsored) ThemeSelection offers a curated collection of high-quality, customizable themes and admin dashboard templates, perfect for creating stunning, responsive websites. Explore their professional designs and transform your web development experience with Free Bootstrap, NextJS, VueJS admin templates, and more! 🔵 Sneat Free Bootstrap Admin Template This free Bootstrap admin template offers a sleek and modern design, packed with customizable components to streamline your workflow. With over 900 stars on Github, Sneat is one of the most used bootstrap dashboards. Ideal for creating dynamic and responsive Bootstrap dashboard templates, Sneat is your go-to Bootstrap admin template for a polished user experience. ⬇️ Download here ⚫ Materio Free MUI NextJS Admin Template This free NextJS dashboard template combines the robustness of MUI with the efficiency of NextJS, providing powerful features for the admin template. The only Open Source NextJS 14-based admin template with App router support. Perfect for developers seeking a cutting-edge NextJS admin dashboard template to enhance their productivity. It has over 1.4k stars on GitHub. ⬇️ Download here 🟢 Materio Free Vuetify VueJS Admin Template This free Vue admin template offers comprehensive tools and features, making it an excellent choice for creating an intuitive Vue admin panel. With its sleek design and rich functionality, this free VueJS admin dashboard is the perfect Vuejs admin template for your next project. ⬇️ Download here Visit ThemeSelection today and take the first step toward a seamless web development experience! Explore their Free Admin Templates, UI Kits, and Bundle deals! Colors & palettes 2. Culrs Culrs is a color palette generator that provides curated color palettes for designers and developers. It helps in creating visually appealing web designs by offering a variety of color combinations that can be used to enhance the aesthetic appeal of web projects. 3. ShadowLord ShadowLord is a tool for generating CSS box-shadow effects. It allows developers to easily create complex shadow effects with customizable options, saving time and effort in designing shadows manually. This improves the visual depth and professionalism of web designs. 4. ShaderGradient ShaderGradient is a gradient generator that uses shaders to create dynamic and visually stunning gradients. This tool can be used to produce unique background effects, enhancing the overall user experience of web interfaces with eye-catching designs. 5. Color Wheel The Canva Color Wheel is an interactive tool for selecting color schemes. It helps developers and designers find the perfect color combinations based on color theory principles, ensuring harmony and balance in web designs, thus boosting the visual consistency of projects. 6. Spectrum Spectrum provides a comprehensive range of color spectrums and palettes. It assists developers in choosing precise color shades for their projects, ensuring that the chosen colors work well together to create a cohesive and appealing visual experience. Fonts & pairings 7. Google Fonts Google Fonts offers a comprehensive library of free, open-source fonts. It enables developers to enhance their web projects with a wide variety of typographic styles, ensuring better readability and aesthetic appeal. 8. Free Faces Free Faces is a curated collection of free-to-use typefaces. This tool helps developers and designers find unique and professional fonts without licensing concerns, enhancing the visual impact of their work. 9. Fontjoy Fontjoy uses machine learning to generate font pairings. It helps developers and designers find harmonious font combinations, saving time and effort in selecting complementary typefaces. Icons 10. Feather Icons Feather Icons is a collection of simple and elegant open-source icons. These icons can be easily customized and integrated into web projects, enhancing the visual elements and user interface. 11. Google Icons Google Icons offers a vast library of icons that are easy to integrate into web projects. The tool improves the visual clarity and usability of web interfaces. 12. Iconic Iconic allows developers to organize, customize, and integrate icons into their projects seamlessly. This tool helps streamline the design process, ensuring that icons are consistent and effectively enhance the user experience. Illustrations 13. Undraw Undraw offers a collection of customizable illustrations that can be used for websites and apps. These illustrations can be easily integrated into projects to enhance visual storytelling and improve user engagement with appealing graphics. 14. Absurd Design Absurd Design provides a library of hand-drawn illustrations that add a unique and quirky touch to web projects. These illustrations can be used to create a distinctive visual identity, making websites stand out with their unconventional style. 15. Patternkid Patternkid is a tool for generating unique, kid-friendly patterns. These patterns can be used as backgrounds or decorative elements in web designs, particularly for child-focused websites, adding a playful and engaging visual element. 16. Error 404 Error 404 Fun offers creative and humorous illustrations specifically designed for 404 error pages. By using these illustrations, developers can turn an otherwise frustrating user experience into a delightful one, maintaining user engagement even when a page is not found. Stock photos & videos 17. Unsplash Unsplash is a website offering a large collection of high-resolution, royalty-free photos. Web developers can use these images to enhance the visual appeal of their websites, adding high-quality visuals without worrying about copyright issues. 18. Pexels Pexels provides free stock photos and videos that can be used for personal and commercial projects. It helps developers find high-quality visuals quickly, improving the overall look of web projects and saving time on sourcing images. 19. Pixabay Pixabay offers a vast library of free images, videos, and music. It’s a valuable resource for developers needing multimedia content for their websites, ensuring visually rich and engaging web designs without the hassle of licensing concerns. Writing has always been my passion, and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to my newsletter! Also, connect with me on Twitter, LinkedIn, and GitHub! Finding useful web development resources can be overwhelming for both beginners and experienced developers. With so many websites and web applications available, it can be challenging to identify the best ones. I decided to curate some of my favorite front-end resources for colors and palettes, fonts, icons, illustrations, stock photos, and videos to help web developers improve their resource stack and save time on projects. I hope these resources will help you stay informed, improve your productivity, and navigate the ever-evolving landscape of web development. Each resource will include a direct link, a description, and an image preview. 1. ThemeSelection (Sponsored) ThemeSelection ThemeSelection offers a curated collection of high-quality, customizable themes and admin dashboard templates , perfect for creating stunning, responsive websites. admin dashboard templates Explore their professional designs and transform your web development experience with Free Bootstrap, NextJS, VueJS admin templates, and more! 🔵 Sneat Free Bootstrap Admin Template Sneat Free Bootstrap Admin Template This free Bootstrap admin template offers a sleek and modern design, packed with customizable components to streamline your workflow. With over 900 stars on Github, Sneat is one of the most used bootstrap dashboards. Bootstrap admin template Ideal for creating dynamic and responsive Bootstrap dashboard templates, Sneat is your go-to Bootstrap admin template for a polished user experience. ⬇️ Download here ⬇️ Download here ⚫ Materio Free MUI NextJS Admin Template Materio Free MUI NextJS Admin Template This free NextJS dashboard template combines the robustness of MUI with the efficiency of NextJS, providing powerful features for the admin template. The only Open Source NextJS 14-based admin template with App router support. NextJS dashboard template Perfect for developers seeking a cutting-edge NextJS admin dashboard template to enhance their productivity. It has over 1.4k stars on GitHub. ⬇️ Download here ⬇️ Download here 🟢 Materio Free Vuetify VueJS Admin Template Materio Free Vuetify VueJS Admin Template This free Vue admin template offers comprehensive tools and features, making it an excellent choice for creating an intuitive Vue admin panel. Vue admin template With its sleek design and rich functionality, this free VueJS admin dashboard is the perfect Vuejs admin template for your next project. ⬇️ Download here ⬇️ Download here Visit ThemeSelection today and take the first step toward a seamless web development experience! ThemeSelection Explore their Free Admin Templates , UI Kits , and Bundle deals ! Free Admin Templates UI Kits Bundle deals Colors & palettes 2. Culrs Culrs Culrs is a color palette generator that provides curated color palettes for designers and developers. It helps in creating visually appealing web designs by offering a variety of color combinations that can be used to enhance the aesthetic appeal of web projects. 3. ShadowLord ShadowLord ShadowLord is a tool for generating CSS box-shadow effects. It allows developers to easily create complex shadow effects with customizable options, saving time and effort in designing shadows manually. This improves the visual depth and professionalism of web designs. 4. ShaderGradient ShaderGradient ShaderGradient is a gradient generator that uses shaders to create dynamic and visually stunning gradients. This tool can be used to produce unique background effects, enhancing the overall user experience of web interfaces with eye-catching designs. 5. Color Wheel Color Wheel The Canva Color Wheel is an interactive tool for selecting color schemes. It helps developers and designers find the perfect color combinations based on color theory principles, ensuring harmony and balance in web designs, thus boosting the visual consistency of projects. 6. Spectrum Spectrum Spectrum provides a comprehensive range of color spectrums and palettes. It assists developers in choosing precise color shades for their projects, ensuring that the chosen colors work well together to create a cohesive and appealing visual experience. Fonts & pairings 7. Google Fonts Google Fonts Google Fonts offers a comprehensive library of free, open-source fonts. It enables developers to enhance their web projects with a wide variety of typographic styles, ensuring better readability and aesthetic appeal. 8. Free Faces Free Faces Free Faces is a curated collection of free-to-use typefaces. This tool helps developers and designers find unique and professional fonts without licensing concerns, enhancing the visual impact of their work. 9. Fontjoy Fontjoy Fontjoy uses machine learning to generate font pairings. It helps developers and designers find harmonious font combinations, saving time and effort in selecting complementary typefaces. Icons 10. Feather Icons Feather Icons Feather Icons is a collection of simple and elegant open-source icons. These icons can be easily customized and integrated into web projects, enhancing the visual elements and user interface. 11. Google Icons Google Icons Google Icons offers a vast library of icons that are easy to integrate into web projects. The tool improves the visual clarity and usability of web interfaces. 12. Iconic Iconic Iconic allows developers to organize, customize, and integrate icons into their projects seamlessly. This tool helps streamline the design process, ensuring that icons are consistent and effectively enhance the user experience. Illustrations 13. Undraw Undraw Undraw offers a collection of customizable illustrations that can be used for websites and apps. These illustrations can be easily integrated into projects to enhance visual storytelling and improve user engagement with appealing graphics. 14. Absurd Design Absurd Design Absurd Design provides a library of hand-drawn illustrations that add a unique and quirky touch to web projects. These illustrations can be used to create a distinctive visual identity, making websites stand out with their unconventional style. 15. Patternkid Patternkid Patternkid is a tool for generating unique, kid-friendly patterns. These patterns can be used as backgrounds or decorative elements in web designs, particularly for child-focused websites, adding a playful and engaging visual element. 16. Error 404 Error 404 Error 404 Fun offers creative and humorous illustrations specifically designed for 404 error pages. By using these illustrations, developers can turn an otherwise frustrating user experience into a delightful one, maintaining user engagement even when a page is not found. Stock photos & videos 17. Unsplash Unsplash Unsplash is a website offering a large collection of high-resolution, royalty-free photos. Web developers can use these images to enhance the visual appeal of their websites, adding high-quality visuals without worrying about copyright issues. 18. Pexels Pexels Pexels provides free stock photos and videos that can be used for personal and commercial projects. It helps developers find high-quality visuals quickly, improving the overall look of web projects and saving time on sourcing images. 19. Pixabay Pixabay Pixabay offers a vast library of free images, videos, and music. It’s a valuable resource for developers needing multimedia content for their websites, ensuring visually rich and engaging web designs without the hassle of licensing concerns. Writing has always been my passion, and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to my newsletter ! my newsletter my newsletter Also, connect with me on Twitter , LinkedIn , and GitHub ! Twitter Twitter LinkedIn LinkedIn GitHub GitHub

Web Devs, Bookmark These 19 Frontend Resources 🎨✨

WildlifeDatasets: an Open-source Toolkit for Animal Re-identification: Conclusion and References

Stories, News & Mentions about PADLE

Padle’s Stories on HackerNoon