Zebble
  • About Zebble
  • Compare
  • Documentation
  • Themes
  • Plug-ins
  • Contact Us

    • What is Zebble?
    • Why Zebble?
    • Structure of a Zebble solution
    • Zebble Designer (UWP)
    • Installing - Introduction
    • Installing Xamarin for Visual Studio
    • Installing for Android
    • Installing for iOS
    • Running and debugging your app on iOS simulator
    • Visual Studio Extensions
    • Preparing the Mac for Xamarin development
    • Preparing Visual Studio for Installing Zebble
    • Introduction to Zebble
    • Creating a new project
    • Hello World - Core Concepts
    • Creating Task List In Zebble
    • Layout: Sizing & Positioning
    • Pages
    • Code behind
    • Event handling
    • Navigation
    • Alerts, Dialog, Prompt and toast
    • View lifecycle
    • Managing Files & Resources
    • Config & Debugging
    • List Views & Grids
    • Forms
    • Page templates
    • Device API
    • Animations
    • Web Api - Part 1 (reading data)
    • Web Api - Part 2 (post and delete)
    • Web Api - Part 3 (server vs client domain model)
    • Gesture events
    • View class
    • Gap class (for padding and margin)
    • Visible vs Ignored vs Enabled
    • Rotation in Zebble
    • Margin & Padding
    • BackGround Properties Of Components
    • Border Properties of Components
    • Opacity
    • Zebble Markup (.zbl files)
    • Data Binding and MVVM
    • Stack class
    • Page class
    • Sizing and positioning
    • ScrollView class
    • FormField class
    • NavBarPage class
    • NavBarTabsPage class
    • LazyLoader
    • Layout examples
    • Introduction to UI with C#
    • Shared Properties
    • Button
    • Carousel class
    • Checkbox class
    • DatePicker
    • Drawing class
    • FilePicker class
    • Grid class
    • IconButton class
    • ImageView
    • ItemPicker class
    • ListView & Grid classes
    • OptionsList
    • SearchInput class
    • Slider class
    • Switch class
    • Tabs Class
    • TextInput class
    • TextView
    • TimePicker
    • TreeView
    • Waiting Indicator
    • WebView class (displaying html)
    • C# Methods and Properties Of UI Components
    • Nav.Forward() vs Nav.Go()
    • Passing parameters to the destination page
    • Going Back
    • Showing Popup pages
    • Waiting class
    • Hardware Back button (e.g. Android)
    • NavigationBar class
    • Tabs class
    • Caching (pages)
    • Navigation without event handler
    • Styling in Zebble
    • Supported selectors
    • Zebble CSS: Under the hood
    • CSS real-time updates
    • Dynamic expressions in CSS
    • Gradient background colours
    • CSS Pseudo-classes support
    • Flashing on tap using AutoFlash
    • Inline styling
    • CSS property mapping to Zebble
    • Using Bold and Light Fonts in Zebble
    • Using custom fonts in Zebble
    • Use the Windows version
    • Logging messages for Debugging
    • Stepping into Zebble source
    • Exception handling in Zebble
    • Debugging layout and styles
    • Zebble Device API
    • Device.Screen and orientation (landscape | portrait)
    • Code that should run on a specific platform
    • Using Lamp (aka Flash, LED and Torch)
    • Using Compass (Smooth compass)
    • Using Accelerometer (device angle)
    • Using Gyroscope (device motion speed)
    • How to Vibrate the device?
    • Launching the device browser
    • Finding device model and manufacturer
    • Responding to System events
    • Handling device shake event
    • Permissions
    • Permissions declaration (manifest files)
    • Sharing
    • Prompt for rating the app
    • Finding if Internet connection is available
    • Device messaging (Make a phone call, send SMS or Email)
    • Showing a local notification
    • Copying to Clipboard
    • Accessing device contacts
    • Reading and writing into Gallery (albums)
    • Playing & Recording Audio
    • C# async / await
    • Understanding Zebble Threading
    • Debugging - the StackTrace problem
    • Not awaiting (running in parallel)
    • Timer (interval / scheduled running)
    • Post-render changes to the UI (dynamic)
    • Introduction of Geo location
    • Map & Location Services
    • Launch directions to a location (external)
    • Getting current Location
    • Tracking user location
    • Cache and temp files and folders
    • Device.Media: Taking and picking photos
    • Playing an audio file
    • VideoPlayer class
    • Augmented reality
    • Recording audio
    • Virtual Reality
    • Speech Recognition
    • Recording or picking video
    • Playing remote videos in iOS
    • Text to speech
    • Introduction to the importance of Mobile Testing
    • Why and what to test
    • Testing mobile apps on different devices
    • Testing mobile apps
    • Xamarin Profiler
    • Performance optimization
    • Moving a view to another container at run-time
    • Attaching custom data (tag) to objects
    • Saving a view as image
    • Naming best practices
    • Fastest way to update your nuget package
    • Tips for Clean and Brief code
    • Splash screen and icon generation
    • Advice for passing Approval
    • Options for iOS app distribution
    • Test Release (internal and UAT)
    • Application Icons in IOS
    • Submitting to App Store
    • Releasing to App Store
    • Crash reporting
    • Optimized Release Build
    • Introduction to push notifications
    • Registration process (App)
    • Push notification setup - iOS
    • Push notification setup - Android
    • Push notification setup - Windows
    • Sending a push message from the web app
    • Introduction
    • Connecting Zebble to Web API
    • Installation
    • Creating an API class
    • GET APIs
    • Calling a GET API (in the mobile app)
    • POST, PUT, PATCH and DELETE APIs
    • Domain Model
    • Web API and Authentication
    • Versioning
    • Uniquely identifying installations (token)
    • Settings file: config.xml
    • Standard Zebble settings
    • Login/Register with Facebook
    • Creating a composite component / plugin
    • Creating a Zebble component using Html and Javascript
    • CustomRenderedView: Third-party native components / plugins
    • Mapbox
    • Naming considerations
    • Random problems?
    • Display Keyboard for Visual Studio Android Emulator
    • iOS goes mad?
    • Configuring a Windows phone for ad-hoc testing
    • Fixing Error DEP0001 : Unexpected Error: -2147009287 while deploying Windows UWP app on device
    • Fixing Error DEP0001 : Unexpected Error: -1988945906 while deploying Windows UWP app on device
    • Unable tp Connect to the Mac agent from Visual Studio
    • Can't connect to the Mac agent from Visual Studio?
    • Visual Studio using a lot of CPU?
    • Choosing the CPU architecture
    • How to debug Zebble.Exe?
    • How to add a Device API to Zebble source?
    • Introduction: "Relevant" data
    • Secure serialization: PessimisticJsonConverter
    • Accessing the server "Database" remotely from mobile
    • Serialization of properties' data
    • Offline Programming Model
    • Remote database access
    • Zebble.Framework.ISyncTask
    • About Automated UI testing
    • What should we test in mobile applications?
    • Creating an Automated UI Test in Zebble



What is Zebble?


Zebble is a framework for developing natives for iOS, Android, and Windows from a single source code base.

It is a platform to develop cross-platform and multi-platform apps (Windows phone, Android and iOS). In Zebble platform, the code sharing concept is used. Zebble can be compared with the Xamarin Forms concept. But unlike Xamarin Forms, Zebble is for apps with custom UI designs and high-performance. Zebble is suitable for not only enterprise, but also consumer-facing apps.

Technology & Development

  • C#: Zebble apps are developed using Xamarin, C# and .NET framework. You can use the native or third party Xamarin components and almost all of your existing C# libraries as long as they are compatible with Xamarin.
     
  • CSS and Markup: Thanks to the Zebble build utility (zebble.exe,) your application UI code will be written mostly in Markup and CSS, with a very declarative syntax, just like web apps. Your code is then converted into C# for execution and debugging.
     
  • 100% Native: Zebble provides you with many abstract UI elements, which are mapped to the native controls on each platform at runtime. Your app UI code is essentially written using this abstract UI language without worrying about the native implementations. Zebble apps are not hybrid. They execute with top performance.

Development Experience

  • Development Speed: In addition to the native mobile platforms, Zebble also has a special Windows rendering engine which you use primarily during development. It allows you to compile and run the app instantly upon every change and get immediate feedback for faster development. Unlike Xamarin Forms or other technologies you don't have to wait for 1-2 minutes for the simulator or device compilation and warm-up to run and test every change in your code.
     
  • Less code: The framework's concepts and fluent API allow you to write the same app with less code, compared to Xamarin Forms.
     
  • Faster to run: Zebble's engine is very efficient and the apps feel faster than Xamarin Forms.
     
  • Extensibility: Zebble UI system has a small core, i.e. view objects that actually mapped to native controls. All other components are just composed of other Zebble views. To create new custom controls, you also just put Zebble view objects together and don't have to deal with the platform specific rendering.

 

 

  • Managing Resources: In Xamarin Forms, the app resources are duplicated in each platform-specific wrapper project, making it harder to manage them. Zebble gives you a central location to store files, and manages all the bundling, etc automatically.

Visual Design

  • Design-led: Xamarin Forms renders the app differently on each platform to mimic the default application style and colors, which makes it inherently hard to achieve a customized visual design.  Zebble instead is design-led. Your app can therefore look the same on all platforms without seeming odd. It encourages you to create a custom visual design for your app - just like how you do with websites. So your app can look unique and pro, and ready for consumer facing.
     
  • Powerful Styling using CSS: Zebble's styling system allows you to centrally define the styles using CSS which is dramatically more powerful and efficient than the Xamarin Forms way. The CSS code in Zebble is automatically converted to the equivalent C# code to be executable in a native world.
     
  • Unified styling: Native platforms typically provide very different mechanisms to style different things that makes learning and code sharing difficult. Zebble introduces generalized visual attributes such as background (color or image), borders, paddings, rounded corners, etc. You can set these on any View object, just like HTML. So you get more fine-grained control and flexibility than Xamarin Forms.



‹
Zebble is a product of Geeks Ltd , a software house based in London, UK. All rights are reserved.

Telephone: +44 (0)845 643 6229

Email: hello@zebble.net

Address: 66a London Road, Morden

Greater London, United Kingdom, SM4 5BE

Privacy Statement
Terms & Conditions
Contact Us